Anwendungen (mehrere) | |
Externe Ebene | Views (mehrere) |
---|---|
↓↓ Logische Datenunabhängigkeit ↓↓ | |
Konzeptionelle Ebene | |
↓↓ Physische Datenunabhängigkeit ↓↓ | |
Interne Ebene | Speicherformat |
(Minimal bedeutet nicht: Die wenigsten Attribute
Schema | R = (id:Integer, Name:String) |
---|---|
Ausprägung | r = {(1, Alice), (2, Bob), (42, Eve)} |
Schema | R = {id, Name} mit dom(id) = Integer, dom(Name) = String |
---|---|
Ausprägung | r = {t1, t2, t3} mit t1(id) = 1, t1(Name) = Alice, t2(id) = 2, t2(Name) = Bob, t3(id) = 42, t3(Name) = Eve |
Identisch
DISTINCT
bei umsetzung!!)t ∈ Schema ⇔ Schema(t) t[A] ⇔ t.A
Ψ(r | t): Ersetze t in Ψ(r | t) mit dem konkreten Tupel r
Quantoren sind nur im Relationenkalkül möglich.
Variable ist …
Es ist möglich unendlich (nicht speicherbare) Relationen zu beschreiben.
Eine Relation ist sicher wenn alle Vaiablen x einer (gespeicherten) Relation angehören Schema(x).
Tupelkalkül | Bereichskalkül |
---|---|
Alle Großstädte in Bayern | |
Schema(t) = Schema(Städte) {t | Städte(t) ∧ f[Land] = Bayern ∧ t[SEinw] ≥ 500000} | |
In welchem Land liegt Passau | |
Schema(t) = (Land:String) {t | (∃ u ∈ Städte)(u.Sname = Passau ∧ u.Land = t.Land} | $\{ x_3 \mid \exists x_1, x_2 : (\text{Städte}(x_1, x_2, x_3) \wedge x_1 = \text{Passau}) \}$ |
$\{ x_3 \mid \exists x_2 : (\text{Städte}(\text{Passau}, x_2, x_3)) \}$ | |
CDU-regierte Städte | |
Schema(t) = Schema(Städte) {t | Städte(t) ∧ (∃ u ∈ Länder)(u.Lname = t.Land ∧ u.Partei = CDU) } | $\{x_1 \mid \exists x_2, x_3, y_2 : (\text{Städte}(x_1, x_2, x_3) \wedge \text{Länder}(x_3, y_2, \text{CDU}))\}$ |
SPD alleinregierte Länder | |
Schema(t) = SChema(Länder) {t | Länder(t) ∧ (∀ u ∈ Länder)(u.LName = t.LName ⇒ u.Partei = SPD} | $\{x_1 \mid \exists x_2 : (\text{Länder}(x_1, x_2, \text{SPD}) \wedge \not \exists y_3 : \text{Länder}(x_1, x_2, y_3) \wedge y_3 \ne \text{SPD} \}$ |
Schema(t) = SChema(Länder) {t | Länder(t) ∧ (∀ u ∈ Länder)(u.LName = t.LName ⇒ u.Partei = SPD} |
integer | integer4 | int | |
smallint | integer2 | ||
float( p) | float | Bits der mantisse (nicht Exponent) | |
decimal( p, q) | numeric( p, q) | Exakte Komma Zahlen. p Stellen gesamt, davon q Nachkommastellen. | |
character( n) | char( n) | ||
character varying( n) | varchar( n) | ||
date | |||
time | |||
timestamp |
http://www.postgresql.org/docs/9.2/static/datatype-numeric.html
NOT NULL
PRIMARY KEY
UNIQUE
REFERENCES
t(
a)
DEFAULT
wCHECK
fPRIMARY KEY (
a1,
a2, …)
UNIQUE (
a1,
a2, …)
FOREIGN KEY (
a1,
a2, …) REFERENCES
t(
b1,
b2, …)
CHECK
fUNIQUE
UNIQUE (
a1,
a2, …)
PRIMARY KEY
PRIMARY KEY (
a1,
a2, …)
REFERENCES
t(
a)
FOREIGN KEY (
a1,
a2, …) REFERENCES
t(
b1,
b2, …)
Folgende sachen können am Ende einer REFERENCES
Angabe stehen
ON DELETE SET NULL
NULL
gesetztON DELETE CASCADE
ON UPDATE CASCADE
a + b | a - b | a * b | a / b |
a = b | a <> b | ||
a < b | a > b | a <= b | a >= b |
a IS NULL | a IS NOT NULL | ||
a IN (…) | |||
a AND b | a OR b | a NOT b |
s1 || s2 | CHAR_LENGTH(s) | SUBSTRING(s FROM pos [FOR len]) | a LIKE '...' |
%
0…n beliebige Zeichen_
1 beliebiges ZeichenCREATE TABLE name ( name typ constraints, name typ constraints, integritätsbedingungen )
DROP TABLE name
ALTER TABLE name ADD ( name typ constraints, name typ constraints )
ALTER TABLE name DROP ( name, name )
ALTER TABLE name MODIFY ( name typ constraints, name typ constraints )
SELECT [DISTINCT] *, t.*, t.a, 42, 32 AS Foo -- Hier AS FROM t, Unisinn u -- KEIN AS WHERE
INSERT INTO name [(a1, a2)] VALUES (v11, v21), (v12, v22)
INSERT INTO name (a1, a2) (SELECT ...)
UPDATE name SET a1=v1, a2=v2 [WHERE ...]
DELETE FROM name [WHERE ...]
NATURAL JOIN t | Natural Join | $A \bowtie B$ | Vergleich aller gleichbenannten |
JOIN t USING(id) | Equi Join | $A \underset{a = b}{\bowtie} B$ | |
JOIN t ON f | Theta Join | $A \underset{a \Theta b}{\bowtie} B$ | Θ = Vergleichsoperator |
Join Art | Verlustfreie Seite | NULL | ||
---|---|---|---|---|
L | R | L | R | |
[INNER] JOIN | ||||
LEFT [OUTER] JOIN | ✓ | ✓ | ||
RIGHT [OUTER] JOIN | ✓ | ✓ | ||
FULL [OUTER] JOIN | ✓ | ✓ | ✓ | ✓ |
WHERE EXISTS (SELECT ...) -- Ergebnis Form egal WHERE NOT EXISTS (SELECT ...) -- Ergebnis Form egal WHERE ... a Θ ALL (SELECT ...) -- Ergebnis genau ein Attribut, aber mehre Tupel WHERE ... a Θ SOME/MANY (SELECT ...) -- Ergebnis genau ein Attribut, aber mehre Tupel WHERE ... a IN (SELECT ...) -- Ergebnis genau ein Attribut, aber mehre Tupel
GROUP BY x HAVING SUM(y) > 42
keine Aggregartfunktionen in WHERE
In SELECT
nur erlaubt
COUNT
SUM
AVG
MAX
MIN
In SELECT
nicht erlaubt
MAX(x)
Befehl | Zähle | |
---|---|---|
NULL | doppelte | |
COUNT(DISTINCT a) | ||
COUNT([ALL] a) | ✓ | |
COUNT(*) | ✓ | ✓ |
ORDER BY a [ASC/DESC], b [ASC/DESC], ...
ASC
: 0, 1, 2, … (default)DESC
: 9, 8, 7, …Typ jedes Attributs muss kompatibel sein
[Im Gegensatz zur relationalen Algebra, wo Typ und Name jedes Attributs übereinstimmen muss (Schemata identisch)]
SELECT ... UNION/UNION ALL/EXCEPT/MINUS/INTERSECT [CORRESPONDING] SELECT ...
CORRESPONDING
beschränkt Ergebniss auf gleiche Namen. Die Position ist dann egal.SELECT
NULL
in SELECT
bei fehlenden Werten.Finde Paare mit gleicher Eigenschaft <code sql> SELECT DISTINCT t1.name, t2.name FROM Foo t1, Foo t2 WHERE
t1.attrib = t2.attrib AND t1.name < t2.name -- Macht aus (AA, AB, BA, BB) : (AB)