DBMS Canonical Cover

Definition of DBMS Canonical Cover

When we update or we need to make some changes in the database. In this situation, the system must be checked if any functional dependencies are getting disturbed during the process of updating the database. In case of disturbance of functional dependence in the new database current state in this situation, the system must take place rollback to avoid functional dependence. When we are working with a large set of functional dependencies, it requires unnecessary more computational time. So DBMS introduces canonical cover, a canonical cover is a set of functional dependence is a simplified set of functional dependence that has the same closure to its original functional dependencies.

Syntax:

α1 -> β1 and α2 -> β2 then we can write α1 = α2

Explanation:

In the above statement, we show that there are two functional dependencies as shown in the above statement. But in canonical form the left-hand side of functional dependency is unique.

How Canonical Cover works in DBMS?

A canonical cover Cc is a set of all functional dependencies Fd that satisfied all the following properties as follows.

1. Functional dependence Fd according to the rules of logic it implies all dependencies in Canonical Cover Cc.
2. Canonical cover Cc according to the rules of logic it implies all dependencies in Functional dependencies
3. There is no functional dependence in canonical cover Cc and contain irrelevant
4. In Canonical cover the left side of functional dependence is unique. Such as A1->B and A2->B2 that means A1 and A2 are different.

Algorithm for Canonical Cover as follows:

Step 1: First use union rules to replace any functional dependence such as A1 -> B1 and A1 -> B2 with A1 -> B1B2.

Step 2: Find functional dependency Fd A -> B with an irrelevant attribute in A or B.

Step 3: If any irrelevant attribute is found delete it from A -> B until functional dependency does not change.

Examples

Let’s see a different example to understand how we can find canonical cover as follows.

Example #1

Consider a given relation(X, Y, Z, W) having some attributes, and below are mentioned functional dependencies as follows.

FD: Y -> X

FD: XW -> Z

FD: Z ->XYW

Solution:

Step 1:

First, decompose all functional dependencies using the decomposition rule. That means a single attribute on the right-hand side. Decomposition of functional dependence as follows.

FD 1: Y -> X

FD 2: XW -> Z

FD 3: Z -> X

FD 4: Z -> Y

FD 5: Z -> W

Step 2:

In the second step, we remove all irrelevant attributes from the left-hand side of functional dependencies by finding the closure as follows.

Only one functional dependency has two or more attributes that means XW -> Z.

{X}⁺ = {X}

{W}⁺ = {W}

In above both cases X can only determine X and W can only determine W, so no irrelevant attributes are present in the above functional dependencies and functional dependencies will remain constant and will not be removed.

Step 3:

Remove all functional dependencies that having transitive relation.

FD 1: Y -> X

FD 2: XW -> Z

FD 3: Z -> X

FD 4: Z -> Y

FD 5: Z -> W

After removing transitive relation the functional dependencies look as follows.

FD 1: Y -> X

FD 2: Z -> Y

FD 3: XW -> Z

FD 4: Z -> W

We combine 2 and 4 functional dependencies together now the canonical cover of the above relation R(X, Y, Z, W) is {Y -> X, Z ->YW, XW -> Z}

Let’s see how we can implement canonical cover in DBMS as follows.

With the help of normal form, we can implement canonical cover. There are four different types of normal form we use in DBMS. In this article, we see the first type of normal form with canonical cover as follows.

First Normal Form (1NF):

This is the first normal form in which all content of the table is unique. It defines some rules as follows.

First rule: we define unique data items in tables.

Second rule: there is no data redundancy in table content.

Third rule: Create a primary key for each table.

Example #2

For the implementation of 1NF, we required a table. So let’s create a table first by using the following statement.

create table cust(
Cust_ID int not null,
Cust_Name varchar (30) not null,
Cust_Age int not null,
Cust_Address varchar (30),
Cust_Orders varchar(15)
);

Explanation

For example, we created a cust table with different attributes such as Cust_ID, cust_Name, Cust_Age, Cust_Address, and Cust_Orders with different data types. After that, we inserted some records into the cust table by using the insert into statement. Illustrate the final result of the above statement by using the following snapshot.

See in the above table data redundancy may occur so let’s see how we can avoid it. In the 1NF form, we break that table into two parts and make it unique. So first we create a table with attributes such as ID, Cust_Name, Cust_Age, and i and primary key as ID as follows.

create table customer(
ID int not null,
Cust_Name varchar (30) not null,
Cust_Age int not null,
Cust_Address varchar (30),
primary key (ID)
);

Explanation

In the above example, we created a customer table with different attributes such as ID, Cust_Name, Cuat_Age, and Cust_Address with different data types. Illustrate the final result of the above statement by using the following snapshot.

Finally, we created one more table name as ordered by using the following statement as follows.

 create table orders(
ID INT NOT NULL,
Cust_ID INT NOT NULL,
Orders VARCHAR(145),
primary key (ID)
);

Explanation

With the help of the above statement, we created an orders table with the above attribute. So in this way we discard the functional dependency of attributes. Illustrate the final result of the above statement by using the following snapshot.

Conclusion

We hope from this article you have understood about the Canonical Cover in DBMS. From the above article, we have learned the basic syntax Canonical Cover. We have also learned how we can implement them in SQL Server with different examples of Canonical Cover. From this article, we have learned how we can handle Canonical Cover in DBMS.

This is a guide to DBMS Canonical Cover. Here we discuss the definition, syntax, How Canonical Cover works in DBMS? along with the examples respectively. You may also have a look at the following articles to learn more –

1. Relational Calculus in DBMS
2. Concurrency Control in DBMS
3. Static Hashing in DBMS
4. Serializability in DBMS