*The Splitting/Combining Rule*

Recall that in "Functional Dependencies" we defined the FD:

A_{1}A_{2}…A_{n} → B_{1}B_{2}..B_{m}

to be a shorthand for the set of FD's:

A_{1}A_{2}...A_{n} → B_{1}

A_{1}A_{2}...A_{n} → B_{2}

. . .

A_{1}A_{2}...A_{n} → B_{m}

That is, we may split attributes on the right side so that only one attribute appears on the right of each FD. Similarly, we can replace a collection of FD's with a common left side by a single FD with the same left side and all the right sides combined into one set of attributes. In either event, the new set of FD's is equivalent to the old. The equivalence noted above can be used in two ways.

● We can replace a FD A_{1}A_{2}. . .A_{n} → B_{1}B_{2} . . . B_{m} by a set

of FD's A_{1}A_{2} . . . A_{n} → B_{i} for i = 1,2,. . . , m. This transformation we call the splitting rule.

● We can replace a set of FD's A_{1}A_{2} … A_{n} → B_{i} for i = 1,2, . . . , m by the

single FD A_{1}A_{2}. . . A_{n} → B_{1}B_{2} . . B_{m}. We call this transformation the combining rule.

For instance, we mentioned in "Functional Dependencies" example, how the set of FD's:

title year → length

title year → filmType

title year → studioName

is equivalent to the single FD:

title year → length filmType studioName

One might imagine that splitting could be applied to the left sides of FD's as well as to right sides. However, there is no splitting rule for left sides, as the following example shows.**Example :** Consider one of the FD's such as:

title year → length

for the relation Movies in "Functional Dependencies" example, If we try to split the left side into

title → length

year → length

then we get two false FD's. That is, title does not functionally determine length, since there can be two movies with the same title (e.g., King Kong) but of different lengths. Likewise, year does not functionally determine length, because there are definitely movies of different lengths made in any one year.

### Tags

- attributes
- functional dependency
- relation
- Instead-Of Triggers
- Schema-Level Constraints and Triggers
- Tuple-Based CHECK Constraints
- Constraints on Attributes and Tuples
- Declaring Foreign-Key Constraints
- Keys Declared With UNIQUE
- Constraints and Triggers
- Modifying Views
- View Definitions
- Introduction to Selection of Indexes
- Default Values / Indexes
- Simple Table Declarations
- Defining a Relation Schema in SQL
- Deletion / Updates
- Database Modifications
- Grouping / HAVING Clauses
- Full-Relation Operations
- Natural Joins / Outerjoins
- Subqueries in FROM Clauses
- Conditions Involving Tuples
- Subqueries
- Union, Intersection, and Difference of Queries
- Interpreting Multirelation Queries
- Disambiguating Attributes
- Queries Involving More Than One Relation
- Null Values and Comparisons Involving NULL
- Selection in SQL
- Projection in SQL
- Additional Constraint Examples
- Extending the Projection Operator
- Extended Operators of Relational Algebra
- Union, Intersection, and Difference of Bags
- Relational Operations on Bags
- A Linear Notation for Algebraic Expressions
- Dependent and Independent Operations
- Renaming
- Combining Operations to Form Queries
- Natural Joins / Theta-Joins
- Selection / Cartesian Product
- Set Operations on Relations
- An Algebra of Relational Operations
- Relational Algebra
- Attribute Lists
- Semistructured Data Representation
- Object-Oriented Versus Object-Relational
- Nested Relations
- What If There Is No Key
- Representing ODL Relationships
- Representing Other Type Constructors
- Representing Set-Valued Attributes
- Nonatomic Attributes in Classes
- Declaring Keys in ODL
- Subclasses in ODL / Multiple Inheritance in ODL
- Types in ODL
- Methods in ODL
- Multiplicity of Relationships
- Relationships in ODL / Inverse Relationships
- Attributes in ODL
- Introduction to ODL
- The Type System
- Decomposition into Fourth Normal Form
- Reasoning About Multivalued Dependencies
- Definition of Multivalued Dependencies
- Multivalued Dependencies
- Third Normal Form
- Boyce-Codd Normal Form
- Projecting Functional Dependencies
- Closing Sets of Functional Dependencies
- The Transitive Rule
- Why the Closure Algorithm Works
- Computing the Closure of Attributes
- Trivial Functional Dependencies
- Rules About Functional Dependencies
- Keys of Relations
- Functional Dependencies
- Using Null Values to Combine Relations - Comparison of Approaches
- An Object-Oriented Approach
- Converting Subclass Structures to Relations
- Handling Weak Entity Sets
- Combining Relations
- From E/R Relationships to Relations
- From Entity Sets to Relations
- Relation Instances
- Equivalent Representations of a Relation
- Tuples / Domains
- Attributes / Schemas
- The Relational Data Model
- Summary of The Entity-Relationship Data Model
- Weak Entity Set Notation
- Requirements for Weak Entity Sets
- Representing Keys in the E/R Model
- Keys in the E/R Model
- The Modeling of Constraints
- Picking the Right Kind of Element
- Design Principles
- Subclasses in the E/R Model
- Attributes on Relationships
- Elements of the E/R Model
- Relational Database Systems