Shirt a Phobia

Sample Page

The relational calculus consists of two calculi, the tuple relational calculus and the domain relational calculus, that is part of the relational model for databases and provide a declarative way to specify database queries. The raison d’être of relational calculus is the formalization of query optimization, which is finding more efficient manners to execute the same query in a database.

The relational calculus is similar to the relational algebra, which is also part of the relational model: While the relational calculus is meant as a declarative language that prescribes no execution order on the subexpressions of a relational calculus expression, the relational algebra is meant as an imperative language: the sub-expressions of a relational algebraic expression are meant to be executed from left-to-right and inside-out following their nesting.

Per Codd’s theorem, the relational algebra and the domain-independent relational calculus are logically equivalent.

Example

A relational algebra expression might prescribe the following steps to retrieve the phone numbers and names of book stores that supply Some Sample Book:

  1. Join book stores and titles over the BookstoreID.
  2. Restrict the result of that join to tuples for the book Some Sample Book.
  3. Project the result of that restriction over StoreName and StorePhone.

A relational calculus expression would formulate this query in the following descriptive or declarative manner:

Get StoreName and StorePhone for book stores such that there exists a title BK with the same BookstoreID value and with a BookTitle value of Some Sample Book.

Mathematical properties

The relational algebra and the domain-independent relational calculus are logically equivalent: for any algebraic expression, there is an equivalent expression in the calculus, and vice versa. This result is known as Codd’s theorem.

Let the relations be:

Bookstores(B)with attributes (BookstoreID, StoreName, StorePhone,…)Titles(T)with attributes (BookstoreID, BookTitle,…) 1) Relational algebra expression The query can be written as: π StoreName, StorePhone (σBookTitle=′Some Sample Book ​(B⋈B.BookstoreID=T.BookstoreID T))

A more explicit equivalent form is: π StoreName, StorePhone (B⋈ B.BookstoreID=T.BookstoreID σ BookTitle=′Some Sample Book′ (T))

The second form is often preferred because it pushes the selection down before the join.

2) Relational calculus expression

In tuple relational calculus, the same query is:

{⟨b.StoreName, b.StorePhone⟩∣Bookstores(b) ∧ ∃t(Titles(t)∧b.BookstoreID=t.BookstoreID∧t.BookTitle=′Some Sample Book′)}

This says: return the store name and phone number of every bookstore b for which there exists a title tuple t with matching BookstoreID and the book title equal to “Some Sample Book”.

3) Mathematical properties that prove the equivalence

The proof rests on the standard equivalence between join, selection, projection, and existential quantification.

Property A: Join + selection corresponds to conjunction with equality B⋈ B.BookstoreID=T.BookstoreID T

means exactly the set of pairs (b,t) such that:

B(b)∧T(t)∧b.BookstoreID=t.BookstoreID

Then applying selection: σ T.BookTitle=′Some Sample Book′​ (⋅)

adds: t.BookTitle=′Some Sample Book′

So the algebraic expression becomes the set of all joined pairs satisfying:

B(b)∧T(t)∧b.BookstoreID=t.BookstoreID∧t.BookTitle=′Some Sample Book′ Property B: Projection corresponds to existential quantification

Projection over (StoreName,StorePhone) removes the title tuple and any other unneeded attributes. In logic, removing attributes corresponds to existentially quantifying them away: π StoreName,StorePhone (⋅)⟺∃t(⋅)

So the projected algebra result corresponds to:

{⟨b.StoreName,b.StorePhone⟩∣∃t(B(b)∧T(t)∧b.BookstoreID=t.BookstoreID∧t.BookTitle=′ Some Sample Book ′ )}

which is exactly the calculus expression.

Property C: Selection pushdown is valid

Because selection only references T.BookTitle, we can rewrite:

σ BookTitle= ′ Some Sample Book ′ ​

(B⋈T)≡B⋈σ BookTitle= ′ Some Sample Book ′ ​

(T)

This is the relational algebra selection-pushdown law. It preserves meaning and often improves efficiency.

4) Final equivalence statement

Thus the relational algebra query and the relational calculus query are equivalent because:

π StoreName,StorePhone ​

(σ BookTitle= ′ Some Sample Book ′ ​

(B⋈T))

denotes the same set as

{⟨b.StoreName, b.StorePhone⟩∣B(b)∧∃t(T(t)∧b.BookstoreID=t.BookstoreID∧t.BookTitle= ′ Some Sample Book ′ )}

This equivalence is the formal proof that the procedural algebra expression and the declarative calculus expression describe the same query.

Purpose

The raison d’être of the relational calculus is the formalization of query optimization. Query optimization consists in determining from a query the most efficient manner (or manners) to execute it. Query optimization can be formalized as translating a relational calculus expression delivering an answer A into efficient relational algebraic expressions delivering the same answer A.

See also

References