Händler-Datenbank (SQL-Beispiel)/Selektion

aus GlossarWiki, der Glossar-Datenbank der Fachhochschule Augsburg

Dieser Artikel erfüllt die GlossarWiki-Qualitätsanforderungen nur teilweise:

Korrektheit: 3
(zu größeren Teilen überprüft) 		Umfang: 4
(unwichtige Fakten fehlen) 		Quellenangaben: 4
(fast vollständig vorhanden) 		Quellenarten: 5
(ausgezeichnet) 		Konformität: 5
(ausgezeichnet)

Die nachfolgenden Beispiele können beispielsweise mit SQLite oder PostgreSQL getestet werden. Installieren Sie dazu die zugehörige Händler-Datenbank.

Die Selektionsfunktion

Eine Selektionsfunktion entfernt Zeilen (= Tupel) aus einer Tabelle.

In jeder Relationalen Algebra gibt es unendlich viele (üblicherweise abzählbar viele) partielle Selektionsfunktionen.

Es sein $ b $ eine Funktion, die jedem Tupel der Art $ (a_1:v_1, \ldots, a_n:v_n) $ einen booleschen Wert (true/$ \top $, false/$ \bot $, unknown/$ U $) zuweist. Dabei seien $ a_1, \ldots a_n $ Attributnamen und $ v_1, \ldots v_n $ Werte der zugehörigen Domänen $ D_1, \ldots D_n $. Die Selektionsfunktion

$ σ_b: R \rightharpoonup R $

überprüft für jedes Tupel $ (a_1:v_1, \ldots, a_n:v_n) $ einer Relation $ r $, die nur Tupel dieser Art enthält, ob die Bedingungsfunktion $ b $ für das jeweilige Tupel den Wert true liefert:

$ b((a_1:v_1, \ldots, a_n:v_n)) = \top $

Ist dies der Fall, so wird das entsprechende Tupel in die Ergebnisrelation eingefügt, anderenfalls wird es „entfernt“.

Für Relationen, die Tupel anderer Bauart enthalten, d. h. andere Attribute oder gleichnamige Attribute mit nicht-kompatiblen Domänen, ist die Selektionsfunktion $ σ_b $ nicht definiert.

Beispiele bezüglich der Händler-Datenbank

In SQL muss in der SELECT-Klausel immer eine Projektionsliste angegeben werden, auch wenn gar keine Projektion benötigt wird. Da es in den folgenden Beispielen nur um die Selektion geht (WHERE-Klausel), wird jeweils die Projektionsklausel SELECT * verwendet. In produktivem Code sollte man dies vermeiden und in SELECT-Klausel immer alle benötigten Attribute explizit aufzählen, da sich die Anzahl und die Reihenfolge der Attribute einer Tabelle im Laufe der Zeit ändern kann (Schemaevolution).

Selektion aller Tupel der Tabelle haendler (Identität)

SELECT *
FROM   haendler
WHERE  true
$ \texttt{haendler} $→  $ σ_{\top}(\texttt{haendler}) $
h_idh_nameh_ortschaft
1 Maier Königsbrunn
2 Müller Königsbrunn
3 Maier Augsburg
4 Huber NULL
5 Schmidt Hamburg
→  
h_idh_nameh_ortschaft
1 Maier Königsbrunn
2 Müller Königsbrunn
3 Maier Augsburg
4 Huber NULL
5 Schmidt Hamburg

Selektion von keinem einzigen Tupel der Tabelle haendler

SELECT h_id, h_name, h_ortschaft
FROM   haendler
WHERE  false

SELECT h_id, h_name, h_ortschaft
FROM   haendler
WHERE  null
$ \texttt{haendler} $→  $ σ_{\bot}(\texttt{haendler}) $
h_idh_nameh_ortschaft
1 Maier Königsbrunn
2 Müller Königsbrunn
3 Maier Augsburg
4 Huber NULL
5 Schmidt Hamburg
→  
h_idh_nameh_ortschaft

Selektion aller Händler aus Königsbrunn

SELECT *
FROM   haendler
WHERE  h_ortschaft = 'Königsbrunn'
$ \texttt{haendler} $→  $ σ_{\texttt{h_ortschaft} = \texttt{'Königsbrunn'}}(\texttt{haendler}) $
h_idh_nameh_ortschaft
1 Maier Königsbrunn
2 Müller Königsbrunn
3 Maier Augsburg
4 Huber NULL
5 Schmidt Hamburg
→  
h_idh_nameh_ortschaft
1 Maier Königsbrunn
2 Müller Königsbrunn

Selektion aller Händler, deren Name mit 'M' beginnt

SELECT *
FROM   haendler
WHERE  h_name LIKE 'M%'

SELECT *
FROM   haendler
WHERE  h_name SIMILAR TO 'M_*'

-- POSIX Regular Expressions (Postgres)
SELECT * 
FROM   haendler
WHERE  h_name ~ '^M'
$ \texttt{haendler} $→  $ σ_{\texttt{h_name LIKE 'M%'}}(\texttt{haendler}) $
h_idh_nameh_ortschaft
1 Maier Königsbrunn
2 Müller Königsbrunn
3 Maier Augsburg
4 Huber NULL
5 Schmidt Hamburg
→  
h_idh_nameh_ortschaft
1 Maier Königsbrunn
2 Müller Königsbrunn
3 Maier Augsburg

Selektion aller Händler, die mindestens drei Warenangebote haben

Es ist auch möglich, komplexe Unteranfragen zur Selektion zu verwenden, wenn diese einen booelschen Wert als Ergebnis liefern. Im folgenden Beispiel wird für jeden Händler mittels eine Aggregationsfunktion gezählt, 

wie viele Warenangebote er hat, d. h., wie oft seine h_id in der Tabelle liefert vorkommt. Diejenigen Händler, für die dieser

Wert größer oder gleich drei ist, werden in der Ergebnistabelle aufgelistet. 

SELECT *
FROM   haendler
WHERE  (SELECT COUNT(*) 
        FROM   liefert
        WHERE  haendler.h_id = liefert.h_id 
       )
       >= 3
$ \texttt{haendler} $→  $ σ_{γ_{\texttt{COUNT(*)}}(σ_{\texttt{haendler.h_id} = \texttt{liefert.h_id}}(\texttt{liefert})) \gt 3}(\texttt{haendler}) $
h_idh_nameh_ortschaft
1 Maier Königsbrunn
2 Müller Königsbrunn
3 Maier Augsburg
4 Huber NULL
5 Schmidt Hamburg
→  
h_idh_nameh_ortschaft
1 Maier Königsbrunn
2 Müller Königsbrunn
4 Huber NULL

Selektion aller Händler, deren Ortschaft auf 'burg' endet

SELECT *
FROM   haendler
WHERE  h_ortschaft LIKE '%burg'

SELECT *
FROM   haendler
WHERE  h_ortschaft SIMILAR TO '_*burg'

-- POSIX Regular Expressions (Postgres)
SELECT * 
FROM   haendler
WHERE  h_ortschaft ~ 'burg$'
$ \texttt{haendler} $→  $ σ_{\texttt{h_ortschaft LIKE '%burg'}}(\texttt{haendler}) $
h_idh_nameh_ortschaft
1 Maier Königsbrunn
2 Müller Königsbrunn
3 Maier Augsburg
4 Huber NULL
5 Schmidt Hamburg
→  
h_idh_nameh_ortschaft
3 Maier Augsburg
5 Schmidt Hamburg

Achtung: Dies ist eine teure Operation, da die Gesamte Händler-Tabelle durchlaufen und jeder Händlername überprüft werden muss. Endtrunkierung sollte grundsätzlich vermieden werden. Stattdessen sollte man einen Volltextindex verwenden, der Endtrunkierung unterstützt.

Selektion aller liefert-Tupel, bei denen die Lieferzeit bekannt ist

SELECT * 
FROM   liefert 
WHERE  l_lieferzeit IS NOT NULL;
$ \texttt{liefert} $→  $ σ_{\texttt{l_lieferzeit IS NOT NULL}}(\texttt{liefert}) $
h_id w_id l_preis l_lieferzeit
1 1 200.00 1
1 1 194.00 6
1 2 100.00 NULL
1 3 150.00 7
1 4 10.00 1
1 5 5.00 1
2 1 160.00 NULL
2 1 190.00 1
2 2 180.00 NULL
2 3 170.00 4
3 1 195.00 2
3 2 190.00 1
4 1 150.00 3
4 3 180.00 5
4 3 199.00 1
→  
h_id w_id l_preis l_lieferzeit
1 1 200.00 1
1 1 194.00 6
1 3 150.00 7
1 4 10.00 1
1 5 5.00 1
2 1 190.00 1
2 3 170.00 4
3 1 195.00 2
3 2 190.00 1
4 1 150.00 3
4 3 180.00 5
4 3 199.00 1

Selektion aller liefert-Tupel, bei denen die Lieferzeit unbekannt ist

SELECT * 
FROM   liefert 
WHERE  l_lieferzeit IS NOT NULL;
$ \texttt{liefert} $→  $ σ_{\texttt{l_lieferzeit IS NOT NULL}}(\texttt{liefert}) $
h_id w_id l_preis l_lieferzeit
1 1 200.00 1
1 1 194.00 6
1 2 100.00 NULL
1 3 150.00 7
1 4 10.00 1
1 5 5.00 1
2 1 160.00 NULL
2 1 190.00 1
2 2 180.00 NULL
2 3 170.00 4
3 1 195.00 2
3 2 190.00 1
4 1 150.00 3
4 3 180.00 5
4 3 199.00 1
→  
h_id w_id l_preis l_lieferzeit
1 2 100.00 NULL
2 1 160.00 NULL
2 2 180.00 NULL

Weitere – eher sinnlose – Anfragen an die liefert-Tabelle

Für welche liefert-Tupel ist die Lieferzeit und Händler-ID überein? 

SELECT * 
FROM   liefert 
WHERE  h_id = l_lieferzeit;
$ σ_{\texttt{h_id = l_lieferzeit}}(\texttt{liefert}) $
h_id w_id l_preis l_lieferzeit
1 1 200.00 1
1 4 10.00 1
1 5 5.00 1

Für welche liefert-Tupel ist unbekannt, ob die Lieferzeit und Händler-ID übereinstimmen? 

SELECT * 
FROM   liefert 
WHERE  (h_id = l_lieferzeit) IS UNKNOWN;
$ σ_{\texttt{(h_id = l_lieferzeit) IS UNKNOWN}}(\texttt{liefert}) $
h_id w_id l_preis l_lieferzeit
1 2 100.00 NULL
2 1 160.00 NULL
2 2 180.00 NULL

Man kann Selektionsbedingungen auch in die Select-Klausel an Stelle der Where-Klausel schreiben. Dann erfolgt allerdings keine Selektion, sondern die Testergebnise werden als zusätzliche Attribute ausgegeben. 

SELECT h_id, w_id, l_preis, l_lieferzeit,
       (h_id=w_id AND l_preis > l_lieferzeit) AS "h_id=w_id AND l_preis > l_lieferzeit",
       (h_id=w_id OR  l_preis > l_lieferzeit) AS "h_id=w_id OR  l_preis > l_lieferzeit",
       (h_id=w_id OR  l_preis < l_lieferzeit) AS "h_id=w_id OR  l_preis < l_lieferzeit"
FROM   liefert
$ π_{\texttt{h_id},\, \texttt{w_id}, \texttt{l_preis},\, \texttt{l_lieferzeit},\, \texttt{h_id=w_id AND l_preis} > \texttt{l_lieferzeit AS "h_id=w_id AND l_preis} > \texttt{l_lieferzeit"},\, \ldots}(\texttt{liefert}) $
h_id w_id l_preis l_lieferzeit h_id=w_id AND
l_preis > l_lieferzeit		h_id=w_id OR
l_preis > l_lieferzeit		h_id=w_id OR
l_preis < l_lieferzeit
1 1 200.00 1 truetruetrue
1 1 194.00 6 truetruetrue
1 2 100.00 NULLfalseNULLNULL
1 3 150.00 7 falsetruefalse
1 4 10.00 1 falsetruefalse
1 5 5.00 1 falsetruefalse
2 1 160.00 NULL falseNULLNULL
2 1 190.00 1 falsetruefalse
2 2 180.00 NULL NULLtruetrue
2 3 170.00 4 falsetruefalse
3 1 195.00 2 falsetruefalse
3 2 190.00 1 falsetruefalse
4 1 150.00 3 falsetruefalse
4 3 180.00 5 falsetruefalse
4 3 199.00 1 falsetruefalse

Für welche liefert-Tupel ist die Lieferzeit gleich (=) NULL? 

SELECT * 
FROM   liefert 
WHERE   l_lieferzeit =  NULL; -- an Stelle von l_lieferzeit IS  NULL
$ σ_{\texttt{ l_lieferzeit = NULL}}(\texttt{liefert}) $
h_id w_id l_preis l_lieferzeit

Der Test auf Gleicheit eines Wertes mit NULL liefert stets den Wert UNKNOWN. Daher ist das Ergebnis der Anfrage leer. Korrekt wäre der Test l_lieferzeit IS NULL.

Noch einmal Tests mit NULL

Fehlerhafter Test = NULL: 

SELECT 1 AS ergebnis
WHERE  5 + NULL =  NULL;
$ \texttt{leere_tabelle} $→  $ σ_{\bot}(\texttt{haendler}) $
 →  
ergebnis

Korrekter Test IS NULL: 

SELECT 1 AS ergebnis
WHERE  5 + NULL IS  NULL;
$ \texttt{leere_tabelle} $→  $ σ_{\bot}(\texttt{haendler}) $
 →  
ergebnis
1

Diese Anfragen sind nicht standard-konform, werden aber sowohl von Postgres als auch von SQLite unterstützt. Laut SQL-Standard muss eine Select-Anweisung eine From-Klausel enthalten.[1] Das heißt, müsste man eine Tabelle (z. B. mit Namen one) definieren, die genau Zeile enthält, und in diese beiden Queries eine passende FROM-Klausel (z. B. FROM one) einfügen.

Quellen

  1. ↑ , <query specification>, S. 476, <table expression>, S. 390
  1. Kowarschick (MMDB-Skript): Wolfgang Kowarschick; Vorlesung Multimedia-Datenbanksysteme – Sommersemester 2018; Hochschule: Hochschule Augsburg; Adresse: Augsburg; Web-Link; 2018; Quellengüte: 4 (Skript)
  2. Kowarschick (MMDB): Wolfgang Kowarschick; Vorlesung „Multimedia-Datenbanksysteme“; Hochschule: Hochschule Augsburg; Adresse: Augsburg; Web-Link; 2016; Quellengüte: 3 (Vorlesung), https://kowa.hs-augsburg.de/mmdb/mmdb-beispiele/haendler-datenbank/

Siehe auch

Abgerufen von „https://glossar.hs-augsburg.de/w/index.php?title=Händler-Datenbank_(SQL-Beispiel)/Selektion&oldid=49549“