language. That means it is
based on the relational data model
first published by E.F. Codd in
- 1970. We will give a formal description of the relational model in
- section
- <!--{\it Formal Notion of the Relational Data Model}-->
+ 1970. We will give a formal description of the relational model
+ later (in
+ <xref linkend="formal-notion" endterm="formal-notion">)
but first we want to have a look at it from a more intuitive
point of view.
A table consists of rows and columns where each row represents a
record and each column represents an attribute of the records
contained in the table.
- Figure
+
shows an example of a database consisting of three tables:
+
The Suppliers and Parts Database
- Formal Notion of the Relational Data Model
+ Relational Data Model Formalities
The mathematical concept underlying the relational model is the
for each attribute
- 1 <= i <= k,
+ 1 <= i <= k,
where the values of the attributes are taken from. We often write
a relation scheme as
integers. We define this by assigning a data type to each
attribute. The type of SNAME will be
VARCHAR(20) (this is the
SQL type
- for character strings of length <= 20),
+ for character strings of length <= 20),
the type of SNO will be
INTEGER. With the assignment of a data type we also have selected
a domain for an attribute. The domain of SNAME is the set of all
- character strings of length <= 20,
+ character strings of length <= 20,
the domain of SNO is the set of
all integer numbers.
- Operations in the Relational Data
- Model
+ Operations in the Relational Data Model
- In
+ In the previous section ()
we defined the mathematical notion of
the relational model. Now we know how the data can be stored using a
relational data model but we do not know what to do with all these
projecting out the duplicate column.
- id="join-example">
-
An Inner Join
+
+ id="join-example">An Inner Join
Let's have a look at the tables that are produced by evaluating the steps
For a more detailed description and definition of the relational
- algebra refer to ullman or
- date86.
+ algebra refer to [] or
+ [].
- Recall that we formulated all those relational operators to be able to
- retrieve data from the database. Let's return to our example of
- section
- where someone wanted to know the names of all
- suppliers that sell the part Screw.
- This question can be answered
- using relational algebra by the following operation:
-
- πSUPPLIER.SNAME(σPART.PNAME='Screw'(SUPPLIER ∏ SELLS ∏ PART))
+
+ A Query Using Relational Algebra
+ Recall that we formulated all those relational operators to be able to
+ retrieve data from the database. Let's return to our example from
+ the previous
+ section ()
+ where someone wanted to know the names of all
+ suppliers that sell the part Screw.
+ This question can be answered
+ using relational algebra by the following operation:
-
+πSUPPLIER.SNAME(σPART.PNAME='Screw'(SUPPLIER ∏ SELLS ∏ PART))
+
+
- We call such an operation a query. If we evaluate the above query
- against the tables from figure
- (The suppliers and
- parts database) we will obtain the following result:
+ We call such an operation a query. If we evaluate the above query
+ against the our example tables
+ ()
+ we will obtain the following result:
SNAME
-------
Smith
Adams
-
-
+
+
+
We want to discuss the tuple relational calculus only because it is
the one underlying the most relational languages. For a detailed
discussion on
DRC (and also
- ullman.
+ []
+ or
+ [].
using
TRC we formulate the following query:
{x(SNAME) ∣ x ∈ SUPPLIER ∧ \nonumber
∃ y ∈ SELLS ∃ z ∈ PART (y(SNO)=x(SNO) ∧ \nonumber
z(PNO)=y(PNO) ∧ \nonumber
z(PNAME)='Screw')} \nonumber
+
- Evaluating the query against the tables from figure
+ Evaluating the query against the tables from
- (The suppliers and parts database)
again leads to the same result
- as in example
+ as in
.
algorithm) by which an arbitrary expression of the relational
calculus can be reduced to a semantically equivalent expression of
relational algebra. For a more detailed discussion on that refer to
- date86 and
- ullman.
+ []
+ and
+ [].
The <acronym>SQL</acronym> Language
- As most modern relational languages
SQL is based on the tuple
+ As is the case with most modern relational languages,
+
SQL is based on the tuple
relational calculus. As a result every query that can be formulated
using the tuple relational calculus (or equivalently, relational
algebra) can also be formulated using
SQL. There are, however,
-
Select
+ id="select-title">Select
The most often used command in
SQL is the
Now we will illustrate the complex syntax of the SELECT statement
with various examples. The tables used for the examples are defined in
- figure (The suppliers and parts database).
+ .
Here are some simple examples using a SELECT statement:
-
Simple Query with Qualification
+ id="simple-query">Simple Query with Qualification
To retrieve all tuples from table PART where the attribute PRICE is
greater than 10 we formulate the following query:
Note that the
SQL SELECT corresponds to the
"projection" in relational algebra not to the "selection"
- (see section
- (Relational Algebra).
+ (see for more details).
because there are common named attributes (SNO and PNO) among the
relations. Now we can distinguish between the common named attributes
by simply prefixing the attribute name with the alias name followed by
- a dot. The join is calculated in the same way as shown in example
+ a dot. The join is calculated in the same way as shown in
.
First the Cartesian product
section).
-
Aggregates
+ id="aggregates-example">Aggregates
If we want to know the average cost of all parts in table PART we use
A1, ⃛, Ak.
-
Aggregates
+ id="aggregates-groupby">Aggregates
If we want to know how many parts are sold by every supplier we
formulate the query:
clause.
-
Having
+ id="having-example">Having
If we want only those suppliers selling more than one part we use the
-
Subselect
+ id="subselect-example">Subselect
If we want to know all parts having a greater price than the part
difference of the tuples derived by two subqueries.
-
Union, Intersect, Except
+ id="union-example">Union, Intersect, Except
The following query is an example for UNION:
-
Create Table
+ id="create-title">Create Table
The most fundamental command for data definition is the
-
Table Creation
+ id="table-create">Table Creation
- To create the tables defined in figure
+ To create the tables defined in
the
following
SQL statements are used:
-
Create Index
+ id="index-create">Create Index
To create an index named I on attribute SNAME of relation SUPPLIER
stored data. Instead, the system stores the definition of the
view (i.e. the rules about how to access physically stored base
tables in order to materialize the view) somewhere in the system
- catalogs (see section ). For a
+ catalogs (see
+ ). For a
discussion on different techniques to implement views refer to
- (last updated 1999-05-19)
+ (last updated 1999-06-01)
-
PostgreSQL is
copyright (©) 1998-9
by the Postgres Global Development Group.
&keys;
&array;
&inherit;
+ &mvcc;
&environ;
&manage;
&storage;
&commands;
+
+
&datetime;
projects / postgresql.git / commitdiff