|Oracle® Database Advanced Application Developer's Guide
11g Release 2 (11.2)
Part Number E17125-03
This chapter explains how to use constraints to enforce the business rules associated with your database and prevent the entry of invalid information into tables.
You can define constraints to enforce business rules on data in your tables. Business rules specify conditions and relationships that must always be true, or must always be false. Because each company defines its own policies about things like salaries, employee numbers, inventory tracking, and so on, you can specify a different set of rules for each database table.
When an integrity constraint applies to a table, all data in the table must conform to the corresponding rule. When you issue a SQL statement that modifies data in the table, Oracle Database ensures that the new data satisfies the integrity constraint, without any checking within your program.
You can enforce rules by defining constraints more reliably than by adding logic to your application. Oracle Database can check that all the data in a table obeys an integrity constraint faster than an application can.
For example, to ensure that each employee works for a valid department:
DROP TABLE dept_tab; CREATE TABLE dept_tab ( deptname VARCHAR2(20), deptno INTEGER ); DROP TABLE emp_tab; CREATE TABLE emp_tab ( empname VARCHAR2(80), empno INTEGER, deptno INTEGER );
Create a rule that all values in the department table are unique:
ALTER TABLE dept_tab ADD PRIMARY KEY (deptno);
Create a rule that every department listed in the employee table must match a value in the department table:
ALTER TABLE emp_tab ADD FOREIGN KEY (deptno) REFERENCES dept_tab(deptno);
When you add an employee record to the table, Oracle Database automatically checks that its department number appears in the department table.
To enforce this rule without constraints, you can use a trigger to query the department table and test that each employee's department is valid. This method is less reliable than using constraints, because
SELECT in Oracle Database uses consistent read (CR), so the query might miss uncommitted changes from other transactions.
You might enforce business rules through both application logic and constraints, if you can filter out bad data before attempting an insert or update. This might let you provide instant feedback to the user, and reduce the load on the database. This technique is appropriate when you can determine that data values are wrong or out of range without checking against any data in the table.
All enabled unique and primary keys require corresponding indexes. Create these indexes by hand, rather than letting the database create them. Note that:
Constraints use existing indexes where possible, rather than creating indexes.
Unique and primary keys can use both nonunique and unique indexes. They can even use only the first few columns of nonunique indexes.
At most one unique or primary key can use each nonunique index.
The column orders in the index and the constraint need not match.
If you must check whether an index is used by a constraint, for example when you want to drop the index, the object number of the index used by a unique or primary key constraint is stored in
ENABLED for that constraint. It is not shown in any static data dictionary view or dynamic performance view.
Oracle Database does not automatically index foreign keys.
By default, all columns can contain null values. Define
NULL constraints only for columns that always require values. For example, an employee's manager or hire date might be temporarily omitted. Some employees might not have a commission. Columns like these must not have
NULL constraints. However, an employee name might be required from the very beginning, and you can enforce this rule with a
NULL integrity constraint.
NULL constraints are often combined with other constraints to further restrict the values that can exist in specific columns. For example, the combination of
UNIQUE constraints forces the input of values in the
UNIQUE key, eliminating the possibility that a new row's data conflicts with an existing row's data.
Because Oracle Database indexes do not store keys that are all null, to allow index-only scans of the table or some other operation that requires indexing all rows, you must put a
NULL constraint on at least one indexed column.
NULL constraint like this:
ALTER TABLE table_name MODIFY column_name NOT NULL;
Example 5-1 uses the SQL*Plus command
DESCRIBE to show which columns of the
DEPARTMENTS table have
NULL constraints, and then shows what happens if you try to insert
NULL values in columns that have
Example 5-1 Inserting NULL Values into Columns with NOT NULL Constraints
Name Null? Type ----------------------------------------- -------- ------------ DEPARTMENT_ID NOT NULL NUMBER(4) DEPARTMENT_NAME NOT NULL VARCHAR2(30) MANAGER_ID NUMBER(6) LOCATION_ID NUMBER(4)
Try to insert
INSERT INTO DEPARTMENTS ( DEPARTMENT_ID, DEPARTMENT_NAME, MANAGER_ID, LOCATION_ID ) VALUES (NULL, 'Sales', 200, 1700);
VALUES (NULL, 'Sales', 200, 1700) * ERROR at line 4: ORA-01400: cannot insert NULL into ("HR"."DEPARTMENTS"."DEPARTMENT_ID")
Omitting a value for a column that cannot be
NULL is the same as assigning it the value
INSERT INTO DEPARTMENTS ( DEPARTMENT_NAME, MANAGER_ID, LOCATION_ID ) VALUES ('Sales', 200, 1700);
INSERT INTO DEPARTMENTS ( * ERROR at line 1: ORA-01400: cannot insert NULL into ("HR"."DEPARTMENTS"."DEPARTMENT_ID")
Assign default values to columns that contain typical values. For example, in the
DEPT_TAB table, if most departments are located in New York, then the default value for the
LOC column can be set to
Default values can help avoid errors where there is a number, such as zero, that applies to a column that has no entry. For example, a default value of zero can simplify testing, by changing a test like this:
IF sal IS NOT NULL AND sal < 50000
to the simpler form:
IF sal < 50000
Depending upon your business rules, you might use default values to represent zero or false, or leave the default values as
NULL to signify an unknown value.
Defaults are also useful when you use a view to make a subset of a table's columns visible. For example, you might allow users to insert rows through a view. The base table might also have a column named
inserter, not included in the definition of the view, to log the user that inserts each row. To record the user name automatically, define a default value that invokes the
CREATE TABLE audit_trail ( value1 NUMBER, value2 VARCHAR2(32), inserter VARCHAR2(30) DEFAULT USER);
Default values cannot include expressions that refer to a sequence, PL/SQL function, column,
PRIOR. The data type of a default literal or expression must match or be convertible to the column data type.
Sometimes the default value is the result of a SQL function. For example, a call to
SYS_CONTEXT can set a different default value depending on conditions such as the user name. To be used as a default value, a SQL function must have parameters that are all literals, cannot reference any columns, and cannot invoke any other functions.
If you do not explicitly define a default value for a column, the default for the column is implicitly set to
You can use the keyword
DEFAULT within an
INSERT statement instead of a literal value, and the corresponding default value is inserted.
Whenever practical, use a column containing a sequence number. This satisfies all the other guidelines.
Choose a column whose data values are unique, because the purpose of a primary key is to uniquely identify each row of the table.
Choose a column whose data values never change. A primary key value is only used to identify a row in the table, and its data must never be used for any other purpose.
Choose a column that does not contain any nulls. A
KEY constraint, by definition, does not allow any row to contain a null in any column that is part of the primary key.
Choose a column that is short and numeric. Short primary keys are easy to type. You can use sequence numbers to easily generate numeric primary keys.
Minimize your use of composite primary keys. Although composite primary keys are allowed, they do not satisfy all of the other recommendations. For example, composite primary key values are long and cannot be assigned by sequence numbers.
Choose columns for unique keys carefully. The purpose of these constraints is different from that of primary keys. Unique key constraints are appropriate for any column where duplicate values are not allowed. Primary keys identify each row of the table uniquely, and typically contain values that have no significance other than being unique. Figure 5-1 shows an example of a table with a unique key constraint.
Figure 5-1 Table with a UNIQUE Constraint
Note:You cannot have identical values in the non-null columns of a composite
UNIQUEkey constraint (
UNIQUEkey constraints allow
Some examples of good unique keys include:
An employee social security number (the primary key might be the employee number)
A truck license plate number (the primary key might be the truck number)
A customer phone number, consisting of the two columns
LOCAL_PHONE (the primary key might be the customer number)
A department name and location (the primary key might be the department number)
Although you can declare constraints on views, such constraints do not help maintain data integrity. Instead, they are used to enable query rewrites on queries involving views, which helps performance with materialized views and other data warehousing features. Such constraints are always declared with the
DISABLE keyword, and you cannot use the
VALIDATE keyword. The constraints are never enforced, and there is no associated index.
See Also:Oracle Database Data Warehousing Guide for information about using constraints in data warehousing
Whenever two tables contain one or more common columns, Oracle Database can enforce the relationship between the two tables through a referential integrity constraint. Define a
UNIQUE key constraint on the column in the parent table (the one that has the complete set of column values). Define a
KEY constraint on the column in the child table (the one whose values must refer to existing values in the other table).
Note:In static data dictionary views
R(for referential integrity).
See Also:"Defining Relationships Between Parent and Child Tables" for information about defining additional constraints, including the foreign key
Figure 5-2 shows a foreign key defined on the department number. It guarantees that every value in this column must match a value in the primary key of the department table. This constraint prevents erroneous department numbers from getting into the employee table.
Foreign keys can be composed of multiple columns. Such a composite foreign key must reference a composite primary or unique key of the exact same structure, with the same number of columns and the same data types. Because composite primary and unique keys are limited to 32 columns, a composite foreign key is also limited to 32 columns.
Figure 5-2 Tables with FOREIGN KEY Constraints
By default (without any
CHECK clauses), the
KEY constraint enforces the match none rule for composite foreign keys in the ANSI/ISO standard.
To enforce the match full rule for
NULL values in composite foreign keys, which requires that all components of the key be
NULL or all be non-null, define a
CHECK constraint that allows only all nulls or all non-nulls in the composite foreign key. For example, with a composite key comprised of columns
CHECK ((A IS NULL AND B IS NULL AND C IS NULL) OR (A IS NOT NULL AND B IS NOT NULL AND C IS NOT NULL))
In general, it is not possible to use declarative referential integrity to enforce the match partial rule for
NULL values in composite foreign keys, which requires the non-null portions of the key to appear in the corresponding portions in the primary or unique key of a single row in the referenced table. You can often use triggers to handle this case, as described in Oracle Database PL/SQL Language Reference.
Several relationships between parent and child tables can be determined by the other types of constraints defined on the foreign key in the child table.
No Constraints on the Foreign Key When no other constraints are defined on the foreign key, any number of rows in the child table can reference the same parent key value. This model allows nulls in the foreign key.
This model establishes a one-to-many relationship between the parent and foreign keys that allows undetermined values (nulls) in the foreign key. An example of such a relationship is shown in Figure 5-2 between the
department tables. Each department (parent key) has many employees (foreign key), and some employees might not be in a department (nulls in the foreign key).
NOT NULL Constraint on the Foreign Key When nulls are not allowed in a foreign key, each row in the child table must explicitly reference a value in the parent key because nulls are not allowed in the foreign key.
Any number of rows in the child table can reference the same parent key value, so this model establishes a one-to-many relationship between the parent and foreign keys. However, each row in the child table must have a reference to a parent key value; the absence of a value (a null) in the foreign key is not allowed. The same example in the previous section illustrates such a relationship. However, in this case, employees must have a reference to a specific department.
UNIQUE Constraint on the Foreign Key When a
UNIQUE constraint is defined on the foreign key, only one row in the child table can reference a given parent key value. This model allows nulls in the foreign key.
This model establishes a one-to-one relationship between the parent and foreign keys that allows undetermined values (nulls) in the foreign key. For example, assume that the employee table had a column named
MEMBERNO, referring to an employee membership number in the company insurance plan. Also, a table named
INSURANCE has a primary key named
MEMBERNO, and other columns of the table keep respective information relating to an employee insurance policy. The
MEMBERNO in the employee table must be both a foreign key and a unique key:
To enforce referential integrity rules between the
INSURANCE tables (the
FOREIGN KEY constraint)
To guarantee that each employee has a unique membership number (the
UNIQUE key constraint)
UNIQUE and NOT NULL Constraints on the Foreign Key When both
NULL constraints are defined on the foreign key, only one row in the child table can reference a given parent key value, and because
NULL values are not allowed in the foreign key, each row in the child table must explicitly reference a value in the parent key.
This model establishes a one-to-one relationship between the parent and foreign keys that does not allow undetermined values (nulls) in the foreign key. If you expand the previous example by adding a
NULL constraint on the
MEMBERNO column of the employee table, in addition to guaranteeing that each employee has a unique membership number, you also ensure that no undetermined values (nulls) are allowed in the
MEMBERNO column of the employee table.
Oracle Database allows a column to be referenced by multiple
KEY constraints; there is no limit on the number of dependent keys. This situation might be present if a single column is part of two different composite foreign keys.
When Oracle Database checks a constraint, it signals an error if the constraint is not satisfied. To defer checking constraints until the end of the current transaction, use the
Note:You cannot use the
CONSTRAINTSstatement inside a trigger.
When deferring constraint checks:
Select appropriate data.
You might want to defer constraint checks on
FOREIGN keys if the data you are working with has any of these characteristics:
Tables are snapshots.
Some tables contain a large amount of data being manipulated by another application, which might not return the data in the same order.
Update cascade operations on foreign keys.
Ensure that constraints are deferrable.
After identifying the appropriate tables, ensure that their
PRIMARY key constraints are created
Within the application that manipulates the data, set all constraints deferred before you begin processing any data, as follows:
SET CONSTRAINTS ALL DEFERRED;
(Optional) Check for constraint violations immediately before committing the transaction.
Immediately before the
COMMIT statement, run the
IMMEDIATE statement. If there are any problems with a constraint, this statement fails, and identifies the constraint that caused the error. If you commit while constraints are violated, the transaction rolls back and you get an error message.
In Example 5-2, the
FOREIGN keys of the table
emp are created
DEFERRABLE and then deferred.
Example 5-2 Deferring Constraint Checks
DROP TABLE dept; CREATE TABLE dept ( deptno NUMBER PRIMARY KEY, dname VARCHAR2 (30) ); DROP TABLE emp; CREATE TABLE emp ( empno NUMBER, ename VARCHAR2(30), deptno NUMBER, CONSTRAINT pk_emp_empno PRIMARY KEY (empno) DEFERRABLE, CONSTRAINT fk_emp_deptno FOREIGN KEY (deptno) REFERENCES dept(deptno) DEFERRABLE ); INSERT INTO dept (deptno, dname) VALUES (10, 'Accounting'); INSERT INTO dept (deptno, dname) VALUES (20, 'SALES'); INSERT INTO emp (empno, ename, deptno) VALUES (1, 'Corleone', 10); INSERT INTO emp (empno, ename, deptno) VALUES (2, 'Costanza', 20); COMMIT; SET CONSTRAINTS ALL DEFERRED; UPDATE dept SET deptno = deptno + 10 WHERE deptno = 20;
SELECT * from dept ORDER BY deptno;
DEPTNO DNAME ---------- ------------------------------ 10 Accounting 30 SALES 2 rows selected.
UPDATE emp SET deptno = deptno + 10 WHERE deptno = 20;
1 row updated.
SELECT * from emp ORDER BY deptno;
EMPNO ENAME DEPTNO ---------- ------------------------------ ---------- 1 Corleone 10 2 Costanza 30 2 rows selected.
CONSTRAINTS applies only to the current transaction, and its setting lasts for the duration of the transaction, or until another
CONSTRAINTS statement resets the mode. The
CONSTRAINTS statement applies only for the current session. The defaults specified when you create a constraint remain while the constraint exists.
See Also:Oracle Database SQL Language Reference for more information about the
When Oracle Database uses a unique index to enforce a constraint, and constraints associated with the unique index are dropped or disabled, the index is dropped. To preserve the statistics associated with the index (which would take a long time to re-create), specify the
INDEX clause on the
While enabled foreign keys reference a
UNIQUE key, you cannot disable or drop the
UNIQUE key constraint or the index.
PRIMARYkeys with deferrable constraints must all use nonunique indexes.
To use existing indexes when creating unique and primary key constraints, include
INDEX in the
CONSTRAINT clause. For details and examples, see Oracle Database SQL Language Reference.
See Also:Oracle Database Concepts for more information about indexing foreign keys
However, you can maintain parent/child table relationships across nodes using triggers.
See Also:Oracle Database PL/SQL Language Reference for more information about triggers that enforce referential integrity
Note:If you decide to define referential integrity across the nodes of a distributed database using triggers, be aware that network failures can make both the parent table and the child table inaccessible.
For example, assume that the child table is in the
SALES database, and the parent table is in the
If the network connection between the two databases fails, then some data manipulation language (DML) statements against the child table (those that insert rows or update a foreign key value) cannot proceed, because the referential integrity triggers must have access to the parent table in the
CHECK constraints when you must enforce integrity rules based on logical expressions, such as comparisons. Never use
CHECK constraints when any of the other types of constraints can provide the necessary checking.
CHECK constraints include:
CHECK constraint on employee salaries so that no salary value is greater than 10000.
CHECK constraint on department locations so that only the locations "
YORK", and "
DALLAS" are allowed.
CHECK constraint on the salary and commissions columns to prevent the commission from being larger than the salary.
CHECK constraint requires that a condition be true or unknown for every row of the table. If a statement causes the condition to evaluate to false, then the statement is rolled back. The condition of a
CHECK constraint has these limitations:
The condition must be a boolean expression that can be evaluated using the values in the row being inserted or updated.
The condition cannot contain subqueries or sequences.
The condition cannot include the
USERENV SQL functions.
The condition cannot contain the pseudocolumns
The condition cannot contain the
The condition cannot contain a user-defined function.
CHECK constraints, remember that a
CHECK constraint is violated only if the condition evaluates to false; true and unknown values (such as comparisons with nulls) do not violate a check condition. Ensure that any
CHECK constraint that you define is specific enough to enforce the rule.
For example, consider this
CHECK (Sal > 0 OR Comm >= 0)
At first glance, this rule may be interpreted as "do not allow a row in the employee table unless the employee salary is greater than zero or the employee commission is greater than or equal to zero." But if a row is inserted with a null salary, that row does not violate the
CHECK constraint, regardless of whether the commission value is valid, because the entire check condition is evaluated as unknown. In this case, you can prevent such violations by placing
NULL constraints on both the
Note:If you are not sure when unknown values result in
NULLconditions, review the truth tables for the logical conditions in Oracle Database SQL Language Reference
The order in which the constraints are evaluated is not defined, so be careful not to rely on the order or to define multiple constraints that conflict with each other.
CHECK (column_name IS NOT NULL)
Therefore, you can write
NULL constraints for a single column using either a
NULL constraint or a
CHECK constraint. The
NULL constraint is easier to use than the
In the case where a composite key can allow only all nulls or all values, you must use a
CHECK constraint. For example, this
CHECK constraint allows a key value in the composite key made up of columns
C2 to contain either all nulls or all values:
CHECK ((C1 IS NULL AND C2 IS NULL) OR (C1 IS NOT NULL AND C2 IS NOT NULL))
Example 5-3 and Example 5-4 show how to create simple constraints during the prototype phase of your database design. In these examples, each constraint is given a name. Naming the constraints prevents the database from creating multiple copies of the same constraint, with different system-generated names, if the data definition language (DDL) statement runs multiple times.
Example 5-3 creates tables and their constraints at the same time, using the
Example 5-3 Defining Constraints with the CREATE TABLE Statement
DROP TABLE DeptTab; CREATE TABLE DeptTab ( Deptno NUMBER(3) CONSTRAINT pk_DeptTab_Deptno PRIMARY KEY, Dname VARCHAR2(15), Loc VARCHAR2(15), CONSTRAINT u_DeptTab_Dname_Loc UNIQUE (Dname, Loc), CONSTRAINT c_DeptTab_Loc CHECK (Loc IN ('NEW YORK', 'BOSTON', 'CHICAGO'))); DROP TABLE EmpTab; CREATE TABLE EmpTab ( Empno NUMBER(5) CONSTRAINT pk_EmpTab_Empno PRIMARY KEY, Ename VARCHAR2(15) NOT NULL, Job VARCHAR2(10), Mgr NUMBER(5) CONSTRAINT r_EmpTab_Mgr REFERENCES EmpTab, Hiredate DATE, Sal NUMBER(7,2), Comm NUMBER(5,2), Deptno NUMBER(3) NOT NULL CONSTRAINT r_EmpTab_DeptTab REFERENCES DeptTab ON DELETE CASCADE);
Example 5-4 creates constraints for existing tables, using the
You cannot create a validated constraint on a table if the table contains rows that violate the constraint.
Example 5-4 Defining Constraints with the ALTER TABLE Statement
-- Create tables without constraints: DROP TABLE DeptTab; CREATE TABLE DeptTab ( Deptno NUMBER(3), Dname VARCHAR2(15), Loc VARCHAR2(15) ); DROP TABLE EmpTab; CREATE TABLE EmpTab ( Empno NUMBER(5), Ename VARCHAR2(15), Job VARCHAR2(10), Mgr NUMBER(5), Hiredate DATE, Sal NUMBER(7,2), Comm NUMBER(5,2), Deptno NUMBER(3) ); --Define constraints with the ALTER TABLE statement: ALTER TABLE DeptTab ADD CONSTRAINT pk_DeptTab_Deptno PRIMARY KEY (Deptno); ALTER TABLE EmpTab ADD CONSTRAINT fk_DeptTab_Deptno FOREIGN KEY (Deptno) REFERENCES DeptTab; ALTER TABLE EmpTab MODIFY (Ename VARCHAR2(15) NOT NULL);
See Also:Oracle Database Administrator's Guide for information about creating and maintaining constraints for a large production database
The creator of a constraint must have the ability to create tables (the
TABLE system privilege), or the ability to alter the table (the
ALTER object privilege for the table or the
TABLE system privilege) with the constraint. Additionally,
KEY constraints require that the owner of the table have either a quota for the tablespace that contains the associated index or the
TABLESPACE system privilege.
KEY constraints also require some additional privileges.
Assign names to constraints
CHECK using the
CONSTRAINT option of the constraint clause. This name must be unique among the constraints that you own. If you do not specify a constraint name, one is assigned automatically by Oracle Database.
Choosing your own name makes error messages for constraint violations more understandable, and prevents the creation of duplicate constraints with different names if the SQL statements are run more than once.
See the previous examples of the
TABLE statements for examples of the
CONSTRAINT option of the
constraint clause. The name of each constraint is included with other information about the constraint in the data dictionary.
See Also:"Viewing Information About Constraints" for examples of static data dictionary views
This section explains the mechanisms and procedures for manually enabling and disabling constraints.
An integrity constraint represents an assertion about the data in a database. This assertion is always true when the constraint is enabled. The assertion might not be true when the constraint is disabled, because data that violates the integrity constraint can be in the database.
When loading large amounts of data into a table using SQL*Loader
When performing batch operations that make massive changes to a table (such as changing each employee number by adding 1000 to the existing number)
When importing or exporting one table at a time
Temporarily turning off constraints can speed up these operations.
When you define an integrity constraint (using either
TABLE), Oracle Database enables the constraint by default. For code clarity, you can explicitly enable the constraint by including the
ENABLE clause in its definition, as in Example 5-5.
Example 5-5 Creating Enabled Constraints
/* Use CREATE TABLE statement to create enabled constraint (ENABLE keyword is optional): */ DROP TABLE t1; CREATE TABLE t1 (Empno NUMBER(5) PRIMARY KEY ENABLE); /* Create table without constraint and then use ALTER TABLE statement to add enabled constraint (ENABLE keyword is optional): */ DROP TABLE t2; CREATE TABLE t2 (Empno NUMBER(5)); ALTER TABLE t2 ADD PRIMARY KEY (Empno) ENABLE;
ENABLE clause when defining a constraint for a table to be populated a row at a time by individual transactions. This ensures that data is always consistent, and reduces the performance overhead of each DML statement.
TABLE statement that tries to enable an integrity constraint fails if an existing row of the table violates the integrity constraint. The statement rolls back and the constraint definition is neither stored nor enabled.
See Also:"Fixing Constraint Exceptions" for more information about rows that violate constraints
You define and disable an integrity constraint (using either
TABLE), by including the
DISABLE clause in its definition, as in Example 5-6.
Example 5-6 Creating Disabled Constraints
/* Use CREATE TABLE statement to create disabled constraint */ DROP TABLE t1; CREATE TABLE t1 (Empno NUMBER(5) PRIMARY KEY DISABLE); /* Create table without constraint and then use ALTER TABLE statement to add disabled constraint */ DROP TABLE t2; CREATE TABLE t2 (Empno NUMBER(5)); ALTER TABLE t2 ADD PRIMARY KEY (Empno) DISABLE;
DISABLE clause when defining a constraint for a table to have large amounts of data inserted before anybody else accesses it, particularly if you must cleanse data after inserting it, or must fill empty columns with sequence numbers or parent/child relationships.
TABLE statement that defines and disables a constraint never fails, because its rule is not enforced.
To enable an existing constraint, use the
TABLE statement with the
ENABLE clause, as in Example 5-7.
Example 5-7 Enabling Existing Constraints
-- Create table with disabled constraints: DROP TABLE DeptTab; CREATE TABLE DeptTab ( Deptno NUMBER(3) PRIMARY KEY DISABLE, Dname VARCHAR2(15), Loc VARCHAR2(15), CONSTRAINT uk_DeptTab_Dname_Loc UNIQUE (Dname, Loc) DISABLE, CONSTRAINT c_DeptTab_Loc CHECK (Loc IN ('NEW YORK', 'BOSTON', 'CHICAGO')) DISABLE ); -- Enable constraints: ALTER TABLE DeptTab ENABLE PRIMARY KEY ENABLE CONSTRAINT uk_DeptTab_Dname_Loc ENABLE CONSTRAINT c_DeptTab_Loc;
TABLE statement that attempts to enable an integrity constraint fails if any of the table rows violate the integrity constraint. The statement is rolled back and the constraint is not enabled.
See Also:"Fixing Constraint Exceptions" for more information about rows that violate constraints
To disable an existing constraint, use the
TABLE statement with the
DISABLE clause, as in Example 5-8.
Example 5-8 Disabling Existing Constraints
-- Create table with enabled constraints: DROP TABLE DeptTab; CREATE TABLE DeptTab ( Deptno NUMBER(3) PRIMARY KEY ENABLE, Dname VARCHAR2(15), Loc VARCHAR2(15), CONSTRAINT uk_DeptTab_Dname_Loc UNIQUE (Dname, Loc) ENABLE, CONSTRAINT c_DeptTab_Loc CHECK (Loc IN ('NEW YORK', 'BOSTON', 'CHICAGO')) ENABLE ); -- Disable constraints: ALTER TABLE DeptTab DISABLE PRIMARY KEY DISABLE CONSTRAINT uk_DeptTab_Dname_Loc DISABLE CONSTRAINT c_DeptTab_Loc;
When enabling or disabling
KEY constraints, be aware of several important issues and prerequisites.
UNIQUE key and
KEY constraints are usually managed by the database administrator.
If a row of a table disobeys an integrity constraint, then this row is in violation of the constraint and is called an exception to the constraint. If any exceptions exist, then the constraint cannot be enabled. The rows that violate the constraint must be updated or deleted before the constraint can be enabled.
You can identify exceptions for a specific integrity constraint as you try to enable the constraint.
See Also:"Fixing Constraint Exceptions" for more information about this procedure
When you try to create or enable a constraint, and the statement fails because integrity constraint exceptions exist, the statement is rolled back. You cannot enable the constraint until all exceptions are either updated or deleted. To determine which rows violate the integrity constraint, include the
EXCEPTIONS option in the
ENABLE clause of a
See Also:Oracle Database Administrator's Guide for more information about responding to constraint exceptions
Starting with Oracle8i, you can modify an existing constraint with the
CONSTRAINT clause, as in Example 5-9.
See Also:Oracle Database SQL Language Reference for information about the parameters you can modify
Example 5-9 Modifying Constraints
/* Create & then modify a CHECK constraint: */ DROP TABLE X1Tab; CREATE TABLE X1Tab ( a1 NUMBER CONSTRAINT c_X1Tab_a1 CHECK (a1>3) DEFERRABLE DISABLE ); ALTER TABLE X1Tab MODIFY CONSTRAINT c_X1Tab_a1 ENABLE; ALTER TABLE X1Tab MODIFY CONSTRAINT c_X1Tab_a1 RELY; ALTER TABLE X1Tab MODIFY CONSTRAINT c_X1Tab_a1 INITIALLY DEFERRED; ALTER TABLE X1Tab MODIFY CONSTRAINT c_X1Tab_a1 ENABLE NOVALIDATE; /* Create & then modify a PRIMARY KEY constraint: */ DROP TABLE t1; CREATE TABLE t1 (a1 INT, b1 INT); ALTER TABLE t1 ADD CONSTRAINT pk_t1_a1 PRIMARY KEY(a1) DISABLE; ALTER TABLE t1 MODIFY PRIMARY KEY INITIALLY IMMEDIATE USING INDEX PCTFREE = 30 ENABLE NOVALIDATE; ALTER TABLE t1 MODIFY PRIMARY KEY ENABLE NOVALIDATE;
One property of a constraint that you can modify is its name. Situations in which you would rename a constraint include:
You want to clone a table and its constraints.
You created a constraint with a default system-generated name, and now you want to give it a name that is easy to remember, so that you can easily enable and disable it.
Example 5-10 shows how to find the system-generated name of a constraint and change it.
Example 5-10 Renaming a Constraint
DROP TABLE T; CREATE TABLE T ( C1 NUMBER PRIMARY KEY, C2 NUMBER );
SELECT CONSTRAINT_NAME FROM USER_CONSTRAINTS WHERE TABLE_NAME = 'T' AND CONSTRAINT_TYPE = 'P';
Result (system-generated name of constraint name varies):
CONSTRAINT_NAME ------------------------------ SYS_C0013059 1 row selected.
Rename constraint from name reported in preceding query to
ALTER TABLE T RENAME CONSTRAINT SYS_C0013059 TO T_C1_PK;
SELECT CONSTRAINT_NAME FROM USER_CONSTRAINTS WHERE TABLE_NAME = 'T' AND CONSTRAINT_TYPE = 'P';
CONSTRAINT_NAME ------------------------------ T_C1_PK 1 row selected.
The constraint enforces a rule that is no longer true.
The constraint is no longer needed.
To drop a constraint and all other integrity constraints that depend on it, specify
Example 5-11 Dropping Constraints
-- Create table with constraints: DROP TABLE DeptTab; CREATE TABLE DeptTab ( Deptno NUMBER(3) PRIMARY KEY, Dname VARCHAR2(15), Loc VARCHAR2(15), CONSTRAINT uk_DeptTab_Dname_Loc UNIQUE (Dname, Loc), CONSTRAINT c_DeptTab_Loc CHECK (Loc IN ('NEW YORK', 'BOSTON', 'CHICAGO')) ); -- Drop constraints: ALTER TABLE DeptTab DROP PRIMARY KEY DROP CONSTRAINT uk_DeptTab_Dname_Loc DROP CONSTRAINT c_DeptTab_Loc;
KEY constraints, be aware of several important issues and prerequisites.
KEY constraints are usually managed by the database administrator.
Oracle Database SQL Language Reference for more information about the
DROP clause of the
Oracle Database Administrator's Guide for more information about dropping constraints.
Oracle Database SQL Language Reference for information about the
CONSTRAINTS clause of the
TABLE statement, which drops all referential integrity constraints that refer to primary and unique keys in the dropped table
KEY constraints enforce relationships between columns in different tables. Therefore, they cannot be enabled if the constraint of the referenced primary or unique key is not present or not enabled.
You must use the same data type for corresponding columns in the dependent and referenced tables. The column names need not match.
Because foreign keys reference primary and unique keys of the parent table, and
UNIQUE key constraints are enforced using indexes, composite foreign keys are limited to 32 columns.
If the column list is not included in the
REFERENCES option when defining a
KEY constraint (single column or composite), then Oracle Database assumes that you intend to reference the primary key of the specified table. Alternatively, you can explicitly specify the column(s) to reference in the parent table within parentheses. Oracle Database automatically checks to verify that this column list references a primary or unique key of the parent table. If it does not, then an informative error is returned.
Parent Table The creator of the referential integrity constraint must own the parent table or have
REFERENCES object privileges on the columns that constitute the parent key of the parent table.
Child Table The creator of the referential integrity constraint must have the ability to create tables (that is, the
TABLE system privilege) or the ability to alter the child table (that is, the
ALTER object privilege for the child table or the
TABLE system privilege).
In both cases, necessary privileges cannot be obtained through a role; they must be explicitly granted to the creator of the constraint.
These restrictions allow:
The owner of the child table to explicitly decide which constraints are enforced and which other users can create constraints
The owner of the parent table to explicitly decide if foreign keys can depend on the primary and unique keys in her tables
Prevent Delete or Update of Parent Key The default setting prevents the deletion or update of a parent key if there is a row in the child table that references the key. For example:
CREATE TABLE Emp_tab ( FOREIGN KEY (Deptno) REFERENCES Dept_tab);
Delete Child Rows When Parent Key Deleted The
CASCADE action allows parent key data that is referenced from the child table to be deleted, but not updated. When data in the parent key is deleted, all rows in the child table that depend on the deleted parent key values are also deleted. To specify this referential action, include the
CASCADE option in the definition of the
KEY constraint. For example:
CREATE TABLE Emp_tab ( FOREIGN KEY (Deptno) REFERENCES Dept_tab ON DELETE CASCADE);
Set Foreign Keys to Null When Parent Key Deleted The
NULL action allows data that references the parent key to be deleted, but not updated. When referenced data in the parent key is deleted, all rows in the child table that depend on those parent key values have their foreign keys set to null. To specify this referential action, include the
NULL option in the definition of the
KEY constraint. For example:
CREATE TABLE Emp_tab ( FOREIGN KEY (Deptno) REFERENCES Dept_tab ON DELETE SET NULL);
To find the names of constraints, what columns they affect, and other information to help you manage them, query the static data dictionary views
*_CONS_COLUMNS, as in Example 5-12.
Example 5-12 Viewing Information About Constraints
DROP TABLE DeptTab; CREATE TABLE DeptTab ( Deptno NUMBER(3) PRIMARY KEY, Dname VARCHAR2(15), Loc VARCHAR2(15), CONSTRAINT uk_DeptTab_Dname_Loc UNIQUE (Dname, Loc), CONSTRAINT c_DeptTab_Loc CHECK (Loc IN ('NEW YORK', 'BOSTON', 'CHICAGO')) ); DROP TABLE EmpTab; CREATE TABLE EmpTab ( Empno NUMBER(5) PRIMARY KEY, Ename VARCHAR2(15) NOT NULL, Job VARCHAR2(10), Mgr NUMBER(5) CONSTRAINT r_EmpTab_Mgr REFERENCES EmpTab ON DELETE CASCADE, Hiredate DATE, Sal NUMBER(7,2), Comm NUMBER(5,2), Deptno NUMBER(3) NOT NULL CONSTRAINT r_EmpTab_Deptno REFERENCES DeptTab ); -- Format columns (optional): COLUMN CONSTRAINT_NAME FORMAT A20; COLUMN CONSTRAINT_TYPE FORMAT A4 HEADING 'TYPE'; COLUMN TABLE_NAME FORMAT A10; COLUMN R_CONSTRAINT_NAME FORMAT A17; COLUMN SEARCH_CONDITION FORMAT A40; COLUMN COLUMN_NAME FORMAT A12;
List accessible constraints in DeptTab and EmpTab:
SELECT CONSTRAINT_NAME, CONSTRAINT_TYPE, TABLE_NAME, R_CONSTRAINT_NAME FROM USER_CONSTRAINTS WHERE (TABLE_NAME = 'DEPTTAB' OR TABLE_NAME = 'EMPTAB') ORDER BY CONSTRAINT_NAME;
CONSTRAINT_NAME TYPE TABLE_NAME R_CONSTRAINT_NAME -------------------- ---- ---------- ----------------- C_DEPTTAB_LOC C DEPTTAB R_EMPTAB_DEPTNO R EMPTAB SYS_C006286 R_EMPTAB_MGR R EMPTAB SYS_C006290 SYS_C006286 P DEPTTAB SYS_C006288 C EMPTAB SYS_C006289 C EMPTAB SYS_C006290 P EMPTAB UK_DEPTTAB_DNAME_LOC U DEPTTAB 8 rows selected.
CHECK constraints in
SELECT CONSTRAINT_NAME, SEARCH_CONDITION FROM USER_CONSTRAINTS WHERE (TABLE_NAME = 'DEPTTAB' OR TABLE_NAME = 'EMPTAB') AND CONSTRAINT_TYPE = 'C' ORDER BY CONSTRAINT_NAME;
CONSTRAINT_NAME SEARCH_CONDITION -------------------- ---------------------------------------- C_DEPTTAB_LOC Loc IN ('NEW YORK', 'BOSTON', 'CHICAGO') SYS_C006288 "ENAME" IS NOT NULL SYS_C006289 "DEPTNO" IS NOT NULL 3 rows selected.
EmpTab, list columns that constitute constraints:
SELECT CONSTRAINT_NAME, TABLE_NAME, COLUMN_NAME FROM USER_CONS_COLUMNS WHERE (TABLE_NAME = 'DEPTTAB' OR TABLE_NAME = 'EMPTAB') ORDER BY CONSTRAINT_NAME;
CONSTRAINT_NAME TABLE_NAME COLUMN_NAME -------------------- ---------- ------------ C_DEPTTAB_LOC DEPTTAB LOC R_EMPTAB_DEPTNO EMPTAB DEPTNO R_EMPTAB_MGR EMPTAB MGR SYS_C006286 DEPTTAB DEPTNO SYS_C006288 EMPTAB ENAME SYS_C006289 EMPTAB DEPTNO SYS_C006290 EMPTAB EMPNO UK_DEPTTAB_DNAME_LOC DEPTTAB LOC UK_DEPTTAB_DNAME_LOC DEPTTAB DNAME 9 rows selected.
Some constraint names are user specified (such as
UK_DEPTTAB_DNAME_LOC), while others are system specified (such as
Each constraint type is denoted with a different character in the
CONSTRAINT_TYPE column. This table summarizes the characters used for each constraint type:
Note:An additional constraint type is indicated by the character "
V" in the
CONSTRAINT_TYPEcolumn. This constraint type corresponds to constraints created using the
These constraints are explicitly listed in the
The conditions for user-defined