 GeeksforGeeks App
Open App Browser
Continue

# Canonical Cover of Functional Dependencies in DBMS

Whenever a user updates the database, the system must check whether any of the functional dependencies are getting violated in this process. If there is a violation of dependencies in the new database state, the system must roll back. Working with a huge set of functional dependencies can cause unnecessary added computational time. This is where the canonical cover comes into play. A canonical cover of a set of functional dependencies F is a simplified set of functional dependencies that has the same closure as the original set F. Important definitions: Extraneous attributes: An attribute of a functional dependency is said to be extraneous if we can remove it without changing the closure of the set of functional dependencies. Canonical cover: A canonical cover of a set of functional dependencies F such that ALL the following properties are satisfied:

• F logically implies all dependencies in .
• logically implies all dependencies in F.
• No functional dependency in contains an extraneous attribute.
• Each left side of a functional dependency in is unique. That is, there are no two dependencies and in such that .

Finding Canonical Cover

Algorithm to compute canonical cover of set F:

repeat
1. Use the union rule to replace any dependencies in and with .    2. Find a functional dependency with an        extraneous attribute either in or in .    3. If an extraneous attribute is found, delete it from .       until F does not change

Example1: Consider the following set F of functional dependencies: F= { A BC B C A B AB C } Steps to find canonical cover:

1. There are two functional dependencies with the same set of attributes on the left: A BC A B These two can be combined to get A BC. Now, the revised set F becomes: F= { A BC B C AB C }
2. There is an extraneous attribute in AB C because even after removing AB C from the set F, we get the same closures. This is because B C is already a part of F. Now, the revised set F becomes: F= { A BC B C }
3. C is an extraneous attribute in A BC, also A B is logically implied by A B and B C (by transitivity). F= { A B B C }
4. After this step, F does not change anymore. So, Hence the required canonical cover is, = { A B B C }

Example2: Consider another set F of functional dependencies: F={ A BC CD E B D E A }

1. The left side of each functional dependency in F is unique.
2. None of the attributes in the left or right side of any functional dependency is extraneous (Checked by applying definition of extraneous attributes on every functional dependency).
3. Hence, the canonical cover is equal to F.

Note: There can be more than one canonical cover of a set F of functional dependencies. How to check whether a set of f.d.’s F canonically cover another set of f.d.’s G? Consider the following two sets of functional dependencies: F = { A B AB C D AC D E } G = { A BC D AB } Now, we are required to find out whether one of these f.d.’s canonically covers the other set of f.d.’s. This means, we need to find out whether F canonically covers G, G canonically covers F, or none of the two canonically cover the other. To find out, we follow the following steps:

• Create a singleton right hand side. This means, the attributes to the right side of the f.d. arrow should all be singleton. The functional dependency D AC gets broken down into two functional dependencies, D A and D C. F = { A B AB C D A D C D E }
• Remove all extraneous attributes. Consider any functional dependency XY Z. If X in itself can determine Z, then the attribute Y is extraneous and can be removed. As we can see, the occurrence of extraneous attributes is possible only in those functional dependencies where there are more than one attributes in the LHS. So, consider the functional dependency AB C. Now, we must find the closures of A and B to find whether any of these is extraneous. =AB =B As we can see, B can be determined from A. This means we can remove B from the functional dependency AB C. F = { A B A C D A D C D E }
• Remove all redundant functional dependencies. Check all f.d.’s one by one, and see if by removing a f.d. X Y, we can still find out Y from X by some other f.d. A more formal way to state this is find without making use of the f.d. we are testing and check whether Y is a part of the closure. If yes, then the f.d. is redundant. Here, when checking for the f.d. D C, we observe that even after hiding it, the closure of D contains C. This is because we can obtain C from D by the combination of two other f.d.’s D A and A C. So, C is redundant. F = { A B A C D A D E }

Now, do the same for G.

• Create a singleton right hand side. This means, the attributes to the right side of the f.d. arrow should all be singleton. G = { A B A C D A D B }
• Remove all extraneous attributes. Since the RHS of all f.d.’s contains only 1 attribute, there is no extraneous attribute possible.
• Remove all redundant functional dependencies. By looping over all f.d.’s and checking the closure of the LHS in all cases, we observe that the f.d. D B is redundant as it can be obtained through a combination of 2 other f.d.’s, D A and A B. G = { A B A C D A }

In DBMS, a canonical cover is a set of functional dependencies that is equivalent to a given set of functional dependencies, but is minimal in terms of the number of dependencies. The process of finding the canonical cover of a set of functional dependencies involves three main steps:

1. Reduction: The first step is to reduce the original set of functional dependencies to an equivalent set that has the same closure as the original set, but with fewer dependencies. This is done by removing redundant dependencies and combining dependencies that have common attributes on the left-hand side.
2. Elimination: The second step is to eliminate any extraneous attributes from the left-hand side of the dependencies. An attribute is considered extraneous if it can be removed from the left-hand side without changing the closure of the dependencies.
3. Minimization: The final step is to minimize the number of dependencies by removing any dependencies that are implied by other dependencies in the set.
4. To illustrate the process, let’s consider a set of functional dependencies: A -> BC, B -> C, and AB -> C. Here are the steps to find the canonical cover:
5. Reduction: We can reduce the set by removing the redundant dependency B -> C and combining the two remaining dependencies into one: A -> B, A -> C.
6. Elimination: We can eliminate the extraneous attribute B from the dependency A -> B, resulting in A -> C.
7. Minimization: We can minimize the set by removing the dependency AB -> C, which is implied by A -> C.
8. The resulting canonical cover for the original set of functional dependencies is A -> C.

The canonical cover is useful because it provides a simplified representation of the original set of functional dependencies that can be used to determine the key, superkey, and candidate key for a relation, as well as to check for normalization violations and perform other database design tasks.

### Features of the canonical cover:

Minimal: The canonical cover is the smallest set of dependencies that can be derived from a given set of dependencies, i.e., it has the minimum number of dependencies required to represent the same set of constraints.

Lossless: The canonical cover preserves all the functional dependencies of the original set of dependencies, i.e., it does not lose any information.

Unique: The canonical cover is unique, i.e., there is only one canonical cover for a given set of dependencies.

Deterministic: The canonical cover is deterministic, i.e., it does not contain any redundant or extraneous dependencies.

Reduces data redundancy: The canonical cover helps to reduce data redundancy by eliminating unnecessary dependencies that can be inferred from other dependencies.

Improves query performance: The canonical cover helps to improve query performance by reducing the number of joins and redundant data in the database.

Facilitates database maintenance: The canonical cover makes it easier to modify, update, and delete data in the database by reducing the number of dependencies that need to be considered.