|Oracle9i Data Warehousing Guide
Release 1 (9.0.1)
Part Number A90237-01
This chapter describes integrity constraints, and discusses:
Integrity constraints provide a mechanism for ensuring that data conforms to guidelines specified by the database administrator. The most common types of constraints include:
To ensure that a given column is unique
To ensure that no null values are allowed
To ensure that two keys share a primary key to foreign key relationship
Constraints can be used for these purposes in a data warehouse:
Constraints verify that the data in the data warehouse conforms to a basic level of data consistency and correctness, preventing the introduction of dirty data.
The Oracle database utilizes constraints when optimizing SQL queries. Although constraints can be useful in many aspects of query optimization, constraints are particularly important for query rewrite of materialized views.
Unlike data in many relational database environments, data in a data warehouse is typically added or modified under controlled circumstances during the extraction, transformation, and loading (ETL) process. Multiple users normally do not update the data warehouse directly, as they do in an OLTP system.
Many significant constraint features have been introduced for data warehousing. Readers familiar with Oracle's constraint functionality in Oracle7 and Oracle8 should take special note of the functionality described in this chapter. In fact, many Oracle7-based and Oracle8-based data warehouses lacked constraints because of concerns about constraint performance. Newer constraint functionality addresses these concerns.
To understand how best to use constraints in a data warehouse, you should first understand the basic purposes of constraints:
In order to use a constraint for enforcement, the constraint must be in the
ENABLE state. An enabled constraint ensures that all data modifications upon a given table (or tables) satisfy the conditions of the constraints. Data modification operations which produce data that violates the constraint fail with a constraint violation error.
To use a constraint for validation, the constraint must be in the
VALIDATE state. If the constraint is validated, then all data that currently resides in the table satisfies the constraint.
Note that validation is independent of enforcement. Although the typical constraint in an operational system is both enabled and validated, any constraint could be validated but not enabled or vice versa (enabled but not validated). These latter two cases are useful for data warehouses.
In some cases, you will know that the conditions for a given constraint are true, so you do not need to validate or enforce the constraint. However, you may wish for the constraint to be present anyway to improve query optimization and performance. When you use a constraint in this way, it is called a belief or
RELY constraint, and the constraint must be in the
RELY state. The
RELY state provides you with a mechanism for telling Oracle9i that a given constraint is believed to be true.
Note that the
RELY state only affects constraints that have not been validated.
This section assumes that you are familiar with the typical use of constraints. That is, constraints that are both enabled and validated. For data warehousing, many users have discovered that such constraints may be prohibitively costly to build and maintain. The topics discussed are:
UNIQUE constraint is typically enforced using a
UNIQUE index. However, in a data warehouse whose tables can be extremely large, creating a unique index can be costly both in processing time and in disk space.
Suppose that a data warehouse contains a table
sales, which includes a column
sales_id uniquely identifies a single sales transaction, and the data warehouse administrator must ensure that this column is unique within the data warehouse.
One way to create the constraint is:
By default, this constraint is both enabled and validated. Oracle implicitly creates a unique index on
sales_id to support this constraint. However, this index can be problematic in a data warehouse for three reasons:
salestable can easily have millions or even billions of rows.
salesis partitioned along a column other than
sales_id, the unique index must be global. This can detrimentally affect all maintenance operations on the
A unique index is required for unique constraints to ensure that each individual row modified in the
sales table satisfies the
For data warehousing tables, an alternative mechanism for unique constraints is:
ALTER TABLE sales ADD CONSTRAINT sales_unique UNIQUE (prod_id, cust_id, time_id, channel_id) DISABLE VALIDATE;
This statement creates a unique constraint, but, because the constraint is disabled, a unique index is not required. This approach can be advantageous for many data warehousing environments because the constraint now ensures uniqueness without the cost of a unique index.
However, there are trade-offs for the data warehouse administrator to consider with
VALIDATE constraints. Because this constraint is disabled, no DML statements that modify the unique column are permitted against the
sales table. You can use one of two strategies for modifying this table in the presence of a constraint:
salestable while the constraint has been dropped is unique.
In a star schema data warehouse,
KEY constraints validate the relationship between the fact table and the dimension tables. A sample constraint might be:
ALTER TABLE sales ADD CONSTRAINT sales_time_fk FOREIGN KEY (time_id) REFERENCES time (time_id) ENABLE VALIDATE;
However, in some situations, a data warehouse administrator may choose to use a different state for the
KEY constraints, in particular, the
ENABLE NOVALIDATE state. A data warehouse administrator might use an
ENABLE NOVALIDATE constraint when either:
Suppose that the data warehouse loaded new data into the fact tables every day, but refreshed the dimension tables only on the weekend. During the week, the dimension tables and fact tables may in fact disobey the
KEY constraints. Nevertheless, the data warehouse administrator might wish to maintain the enforcement of this constraint to prevent any changes that might affect the
KEY constraint outside of the ETL process. Thus, you can create the
KEY constraints every night, after performing the ETL process, as shown here:
ALTER TABLE sales ADD CONSTRAINT sales_time_fk FOREIGN KEY (sales_time_id) REFERENCES time (time_id) ENABLE NOVALIDATE;
NOVALIDATE can quickly create an enforced constraint, even when the constraint is believed to be true. Suppose that the ETL process verifies that a
KEY constraint is true. Rather than have the database re-verify this
KEY constraint, which would require time and database resources, the data warehouse administrator could instead create a
KEY constraint using
The ETL process commonly verifies that certain constraints are true. For example, it can validate all of the foreign keys in the data coming into the fact table. This means that you can trust it to provide clean data, instead of implementing constraints in the data warehouse. You create a
RELY constraint as follows:
ALTER TABLE sales ADD CONSTRAINT sales_time_fk FOREIGN KEY (sales_time_id) REFERENCES time (time_id) RELY DISABLE NOVALIDATE;
RELY constraints, even though they are not used for data validation, can:
RELY constraint is inexpensive and does not impose any overhead during DML or load. Because the constraint is not being validated, no data processing is necessary to create it.
All constraints can be validated in parallel. When validating constraints on very large tables, parallelism is often necessary to meet performance goals. The degree of parallelism for a given constraint operation is determined by the default degree of parallelism of the underlying table.
You can create and maintain constraints before you partition the data. Later chapters discuss the significance of partitioning for data warehousing. Partitioning can improve constraint management just as it does to management of many other operations. For example, Chapter 14, "Maintaining the Data Warehouse", provides a scenario creating
KEY constraints on a separate staging table, and these constraints are maintained during the
You can create constraints on views. The only type of constraint supported on a view is a
This type of constraint is useful when queries typically access views instead of base tables, and the DBA thus needs to define the data relationships between views rather than tables. View constraints are particularly useful in OLAP environments, where they may enable more sophisticated rewrites for materialized views.