Mastering Database Management

0 of 78 lessons complete (0%)

Data Modeling

Dependencies in Database Normalization

You don’t have access to this lesson

Please register or sign in to access the course content.

In the context of database normalization, dependencies refer to the relationships and interactions between attributes (columns) in a relational database table. Understanding dependencies is crucial for designing normalized database schemas that minimize redundancy and anomalies.

Determinant and Dependent

  • The expression X → Y means ‘if I know the value of X, then I can obtain the value of Y’ (in a table or somewhere).
  • In the expression X → Y, X is the determinant and Y is the dependent attribute.
  • The value X determines the value of Y. The value Y depends on the value of X.

Types of Dependencies:

  • A functional dependency exists when one attribute uniquely determines another attribute in a table.
  • Notation: A → B (Attribute A determines attribute B).

Example: Consider a table representing employees with attributes “EmployeeID” and “EmployeeName.”

Table: Employees


Functional Dependency:

  • EmployeeID → EmployeeName


  • In this example, the attribute “EmployeeName” is functionally dependent on the attribute “EmployeeID.”
  • Knowing the “EmployeeID” uniquely determines the corresponding “EmployeeName.”

A partial dependency occurs when a non-prime attribute depends on only part of the primary key, leading to potential redundancy.

Example: Consider a table representing employees and their assigned projects.

Table: EmployeeProjects


Partial Dependency:

  • EmployeeID → ProjectName


  • In this example, “ProjectName” is partially dependent on “EmployeeID.”
  • “ProjectName” depends on part of the primary key (“EmployeeID”) instead of the entire primary key (“EmployeeID,” “ProjectID”).
  • A transitive dependency occurs when an attribute depends on another non-key attribute, which itself depends on the primary key.
  • If A → B and B → C, then A → C is a transitive dependency.

Example: Consider a table representing employees, projects, and project managers.

Table: EmployeeProjects


Transitive Dependency:

  • EmployeeID → ProjectManager
  • ProjectID → ProjectManager


  • In this example, “ProjectManager” is transitively dependent on both “EmployeeID” and “ProjectID.”
  • “ProjectManager” depends on non-key attributes (“EmployeeID” and “ProjectID”).
  • A multi-valued dependency exists when one attribute uniquely determines another attribute, independent of the other attributes.
  • Notation: A →→ B (Attribute A uniquely determines attribute B, independent of other attributes).

Example: Consider a table representing employees and their skills.

Table: EmployeeSkills


Multi-valued Dependency:

  • EmployeeID →→ Skill
  • EmployeeID →→ SkillLevel


  • In this example, “Skill” and “SkillLevel” are multi-valued dependent on “EmployeeID.”
  • Knowing “EmployeeID” uniquely determines both the skills and skill levels of an employee.

  • A non-trivial dependency implies that the relationship between attributes is significant and not implied by a candidate key.
  • In a table with a candidate key (A, B), a dependency like A → B is non-trivial.

Example: Consider a table representing courses and their instructors.

Table: Courses


Non-trivial Dependency:

  • CourseID → Instructor


  • In this example, the dependency “CourseID → Instructor” is non-trivial.
  • It’s not implied by any candidate key; it’s a significant relationship.

Understanding these dependencies helps in the process of normalization, ensuring that a database is well-organized, minimizes redundancy(duplicacy), and avoids anomalies. Each type of dependency plays a role in determining the structure and integrity of a relational database.

Importance of Dependencies in Database Design:

  1. Database Normalization:
    • Dependencies are the foundation of normalization, a process to minimize data redundancy and anomalies in a database.
    • Normal forms (1NF, 2NF, 3NF, BCNF, 4NF, 5NF) are designed to address specific types of dependencies.
  2. Data Integrity:
    • Understanding dependencies helps ensure data integrity by preventing update, insert, and delete anomalies.
    • Proper normalization reduces the risk of inconsistent or conflicting data.
  3. Query Optimization:
    • Well-designed tables, considering dependencies, lead to efficient query performance.
    • Normalized tables simplify queries by avoiding unnecessary joins and redundancies.
  4. Simplified Schema Design:
    • Knowledge of dependencies helps in creating a more simplified and logical schema design.
    • It provides a clear structure for organizing data based on its inherent relationships.