SELECT * FROM // c[_]~~

Nachdem ich die Northwind-Datenbank als meine neue Testdatenbank ausgemacht habe, möchte ich jetzt ein wenig mit dieser rumspielen und euch daran teilhaben lassen. - Man könnte den und die folgenden Beiträge quasi als ein kleines [My]SQL-Tutorial verstehen. - Northwind ist, wie ja bereits in einem älteren Beitrag angemerkt eine Beispieldatenbank von Microsoft für Access oder dem SQL Server 2000. In der neueren Version SQL Server 2005 wurde eine neue Beispieldatenbank (AdventureWorks) für Code-Beispiele herangezogen. Da diese aber für meine momentanen Absichten doch etwas zu umfangreich ist, werde ich die folgenden Beispiele ausschließlich auf der “alten” Northwind-Datenbank zeigen.
Als Datenbank-Management-System werde ich MySQL in der Version 5.0.27 verwenden, theoretisch sind für die allgemeinen SQL-Abfragen auch andere Systeme wie zum Beispiel Postgre, Firebird, die kostenlose Oracle Database 10g XE oder die ebenfalls frei verfügbare IBM DB2 Express-C zu verwenden, wobei ich auf Eigenheiten der unterschiedlichen Datenbank-Systeme in Bezug auf Installation oder Syntax keine weiteren Angaben machen und im folgendem immer von MySQL ausgehen werde.

Start-up

Dann kann es ja losgehen. Falls ihr die Northwind-Datenbank bereits eingespielt habt, dann könnt ihr diesen Absatz getrost überspingen. Ansonten noch einmal in diesen Beitrag schauen und das SQL-Script zum Erstellen und Befüllen der Datenbank runterladen und abspeichern. Danach die Kommandozeile öffnen (achja- ich vergaß zu erwähnen, dass unter Windows XP arbeite), dich mit dem Datenbank-Server verbinden (mysql -r{Benutzer} -p{Passwort}) , eine neue Datenbank erstellen (create database northwind;) und dich mit dieser verbinden (use northwind;). Im nächsten Schritt muss du die Datenbank mit Leben füllen. Dazu das SQL-Script welches du vorher heruntergeladen hast ausführen (source northwind.sql;) und fertig.

Datenbank Analysieren

Als nächstes werden wir uns auf die Analyse der Datenbank bzw. der Datenstruktur stürzen. Also erst einmal erkunden, welche Tabellen mit welchen Attributen in der Datenbank existieren und wie sie zueinander in Relation stehen. Vorrausgesetzt du nutzt keinen grafischen Editor oder sonst ein Tool was dir die DB-Strutkur abbilden kann helfen dir zwei SQL-Statements weiter:

SHOW TABLES;

+----------------------+
| Tables_in_northwind |
+----------------------+
| categories |
| customers |
| employees |
| employeeterritories |
| order_details |
| orders |
| products |
| shippers |
| suppliers |
+----------------------+

EXPLAIN categories;

+--------------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+----------------+
| CategoryID | int(11) | NO | PRI | NULL | auto_increment |
| CategoryName | varchar(15) | NO | MUL | | |
| Description | longtext | YES | | NULL | |
| Picture | longblob | YES | | NULL | |
+--------------+-------------+------+-----+---------+----------------+

Mit der ersten Abfrage werden alle in der Datenbank enthaltenen Tabellen aufgelistet und mit dem zweiten Statement kann man sich für jede einzelne Tabelle ausführliche Informationen zu den Attributen (Field) anzeigen lassen. Da, wie ich finde, ein visuelles Datenbankschema sich immer besser macht, habe ich mit phpMyAdmin mal eines erstellt, welches ihr als PDF herunterladen und verwenden könnt. Die Bezeichnungen der Tabellen und Benennung der Attribute sollte selbsterklärend sein.

Grundlegende Abfragen (SELECT | ORDER BY | LIMIT)

Wir haben nun eine Datenbank inklusive Tabellen angelegt, diese mit Daten befüllt und kennen ihre Struktur. Dann kann es ja losgehen. Greifen wir uns mal die Tabelle products heraus. In dieser sind alle Produkte unserer virtuellen Unternehmensdatenbank enthalten. Uns interessieren zunächst nur mal der Name des Produktes (ProductName), der Preis für eine Einheit (UnitPrice) und der Lagerbestand (UnitsInStock). Kein Problem:

SELECT ProductName, UnitPrice, UnitsInStock FROM products;

+----------------------------------+-----------+--------------+
| ProductName | UnitPrice | UnitsInStock |
+----------------------------------+-----------+--------------+
| Chai | 18.0000 | 39 |
| Chang | 19.0000 | 17 |
| Aniseed Syrup | 10.0000 | 13 |
| Chef Anton's Cajun Seasoning | 22.0000 | 53 |
| Chef Anton's Gumbo Mix | 21.3500 | 0 |
| Grandma's Boysenberry Spread | 25.0000 | 120 |
| Uncle Bob's Organic Dried Pears | 30.0000 | 15 |
| Northwoods Cranberry Sauce | 40.0000 | 6 |
| Mishi Kobe Niku | 97.0000 | 29 |
| Ikura | 31.0000 | 31 |
| Queso Cabrales | 21.0000 | 22 |
| Queso Manchego La Pastora | 38.0000 | 86 |
| Konbu | 6.0000 | 24 |
... (Ausgaben gekürzt)

Zum Sortieren der Ausgabe können wir noch die ORDER BY-Klausel hinzufügen. Standardmäßig wird aufsteigend geordnet (ASC), d.h. die kleinsten Werte werden zuerst angezeigt. Eine absteigenden Reihenfolge kann mit dem Schlüsselwort (DESC) erreicht werden. Nach mehreren Attributen kann auch sortiert werden, dazu müssen diese mit Komma getrennt in der ORDER BY-Klausel angegeben werden. Doch genug der Worte, ein konkretes Beispiel:

SELECT ProductName, UnitPrice, UnitsInStock
FROM products
ORDER BY ProductName DESC;

Gibt alle Produkte absteigend geordnet nach dem Produktnamen aus.

+----------------------------------+-----------+--------------+
| ProductName | UnitPrice | UnitsInStock |
+----------------------------------+-----------+--------------+
| Zaanse koeken | 9.5000 | 36 |
| Wimmers gute Semmelknoedel | 33.2500 | 22 |
| Vegie-spread | 43.9000 | 24 |
| Valkoinen suklaa | 16.2500 | 65 |
| Uncle Bob's Organic Dried Pears | 30.0000 | 15 |
| Tunnbroed | 9.0000 | 61 |
| TourtiÞre | 7.4500 | 21 |
| Tofu | 23.2500 | 35 |
| Thueringer Rostbratwurst | 123.7900 | 0 |
... (Ausgaben gekürzt)

Nehmen wir jetzt noch mit die Kategorie der Produkte (CategoryID) zum Ordnen hinzu, können wir erst nach Produktkategorie und danach nach dem Produktnamen sortieren.

SELECT ProductName, CategoryID, UnitPrice, UnitsInStock
FROM products
ORDER BY CategoryID, ProductName DESC

+----------------------------------+------------+-----------+--------------+
| ProductName | categoryID | UnitPrice | UnitsInStock |
+----------------------------------+------------+-----------+--------------+
| Chai | 1 | 18.0000 | 39 |
| Chang | 1 | 19.0000 | 17 |
| Chartreuse verte | 1 | 18.0000 | 69 |
| Cote de Blaye | 1 | 263.5000 | 17 |
| Guaranß Fantßstica | 1 | 4.5000 | 20 |
| Ipoh Coffee | 1 | 46.0000 | 17 |
| Lakkalikoeoeri | 1 | 18.0000 | 57 |
| Laughing Lumberjack Lager | 1 | 14.0000 | 52 |
| Outback Lager | 1 | 15.0000 | 15 |
| Rhoenbrõu Klosterbier | 1 | 7.7500 | 125 |
| Sasquatch Ale | 1 | 14.0000 | 111 |
| Steeleye Stout | 1 | 18.0000 | 20 |
... (Ausgaben gekürzt)

Die etwas kryptische CategorieID lassen wir erst einmal so stehen, darum kümmern wir uns in dem nächsten Teil des Tutorials wenn wir mit der JOIN-Klausel experimentieren. So fehlt eigentlich nur noch eine SQL-Anweisung und dann sind wir für den heutige Tag durch. (Für alle die sich bis zu der Stelle des Textes durchgekämpft haben und etwas enttäuscht über die sehr einfachen Abfragen sind, kann ich versichern: Es wird noch spannender, aber ich wollte nicht gleich von 0 auf 407 durchstarten. Schön alles Schritt für Schritt… ;))
Aber auf zum letzten Abschnitt! Mit Hilfe der LIMIT-Klausel können die Ergebnisse der Anzahl nach beschränkt werden. D.h. wollen wir zum Beispiel nur die 10 billigsten Produkte aus unserem Sortiment anzeigen, werden die Datensätze wie folgt limitiert:

SELECT ProductName, UnitPrice
FROM products
ORDER BY UnitPrice
LIMIT 10;

+----------------------------+-----------+
| productname | unitPrice |
+----------------------------+-----------+
| Geitost | 2.5000 |
| test | 4.0000 |
| Guaranß Fantßstica | 4.5000 |
| Konbu | 6.0000 |
| Filo Mix | 7.0000 |
| TourtiÞre | 7.4500 |
| Rhoenbrõu Klosterbier | 7.7500 |
| Tunnbroed | 9.0000 |
| Teatime Chocolate Biscuits | 9.2000 |
| Rogede sild | 9.5000 |
+----------------------------+-----------+

Die 10 teuersten Produkte entsprechend mit

SELECT ProductName, UnitPrice
FROM products
ORDER BY UnitPrice DESC
LIMIT 10;

+-------------------------+-----------+
| productname | unitPrice |
+-------------------------+-----------+
| Cote de Blaye | 263.5000 |
| Thueringer Rostbratwurst| 123.7900 |
| Mishi Kobe Niku | 97.0000 |
| Sir Rodney's Marmalade | 81.0000 |
| Carnarvon Tigers | 62.5000 |
| Raclette Courdavault | 55.0000 |
| Manjimup Dried Apples | 53.0000 |
| Tarte au sucre | 49.3000 |
| Ipoh Coffee | 46.0000 |
| Roessle Sauerkraut | 45.6000 |
+-------------------------+-----------+

Alle Klarheiten beseitigt? Dann entspannen, Füße hoch und verdauen. Im nächsten Beitrag werde ich die WHERE-Bedingung, Aggregatfunktionen und vielleicht auch das JOIN-Statement behandeln. Bei Fragen und/oder Unklarheiten könnt ihr entweder mich kontaktieren oder einen Kommentar hinterlassen. Auch bin ich für jegliche Herausforderungen bzgl. dieser Datenbank offen. - Also her mit euren kniffligen Aufgaben, Kontaktaufnahme wie oben beschrieben! ;)