Postgresql: frei verfügbares DBS; sehr nah an SQL-Standard
auch frei verfügbar: MySQL, SQLite
google: postgresql download

kunde(kname KEY, kadr, kto)
auf(kname KEY -> kunde.kname, ware KEY, menge)
lief(lname KEY, ladr, ware KEY, preis)

CREATE TABLE kunde(
  kname TEXT,
  kadr  TEXT,
  kto   INTEGER,
  PRIMARY KEY (kname));
CREATE TABLE auf(
  kname TEXT,
  ware  TEXT,
  menge INTEGER,
  PRIMARY KEY (kname,ware),
  FOREIGN KEY (kname) REFERENCES kunde(kname)
  );
CREATE TABLE lief(
  lname TEXT,
  ladr  TEXT,
  ware  TEXT,
  preis INTEGER,
  PRIMARY KEY (lname,ware));

DROP TABLE lief; DROP TABLE auf; DROP TABLE kunde;

INSERT INTO kunde VALUES ('Weiss','HB; Bibstr',42);
INSERT INTO kunde VALUES ('Rot','HH; Michelweg',0);
INSERT INTO kunde VALUES ('Blau','HB; Bibstr',-21);

INSERT INTO auf VALUES ('Blau','Milch',4);
INSERT INTO auf VALUES ('Blau','Mehl',3);
INSERT INTO auf VALUES ('Weiss','Milch',2);
INSERT INTO auf VALUES ('Rot','Salz',8);

INSERT INTO lief VALUES ('Grau','HB; Rotweg','Milch',55);
INSERT INTO lief VALUES ('Grau','HB; Rotweg','Mehl',33);
INSERT INTO lief VALUES ('Schwarz','HH; Rotweg','Mehl',77);

SELECT * FROM kunde;SELECT * FROM auf;SELECT * FROM lief;

------------------------------------------------------------------------

INSERT INTO kunde VALUES ('Weiss','HB; Bibstr',21);
INSERT INTO auf VALUES ('Rot','Salz',4);
INSERT INTO auf VALUES ('Gruen','Salz',8);

------------------------------------------------------------------------

SELECT kname
FROM   kunde
WHERE  kto<0;

........................................................................

SELECT DISTINCT lname, ladr
FROM   lief
WHERE  ware='Milch' OR ware='Mehl';

SELECT lname, ladr
FROM   lief
WHERE  ware='Milch' OR ware='Mehl';

SELECT l.lname, l.ladr
FROM   lief l
WHERE  l.ware='Milch' OR l.ware='Mehl';

SELECT lief.lname, lief.ladr
FROM   lief
WHERE  lief.ware='Milch' OR lief.ware='Mehl';

........................................................................

SELECT lname, lief.ware
FROM   lief, auf
WHERE  ladr LIKE '%HB%' AND
       lief.ware=auf.ware AND
       kname='Weiss';

SELECT lname, ware
FROM   lief
WHERE  ladr LIKE '%HB%' AND
       ware =ANY ( select ware
                   FROM   auf
                   WHERE  kname='Weiss' );

SELECT lname, ware
FROM   lief
WHERE  ladr LIKE '%HB%' AND
       ware IN ( SELECT ware
                 FROM   auf
                 WHERE  kname='Weiss' );

........................................................................

SELECT l.lname
FROM   lief l, lief lg
WHERE  l.ware=lg.ware AND lg.lname='Grau';

SELECT l.lname
FROM   lief l
WHERE  EXISTS ( SELECT lg.ware
                FROM   lief lg
                WHERE  l.ware=lg.ware AND
                       lg.lname='Grau' );

SELECT DISTINCT l.lname
FROM   lief l
WHERE  EXISTS ( SELECT lg.ware
                FROM   lief lg
                WHERE  l.ware=lg.ware AND
                       lg.lname='Grau' );

SELECT l.lname
FROM   lief l
WHERE  EXISTS ( SELECT *
                FROM   lief lg
                WHERE  l.ware=lg.ware AND
                       lg.lname='Grau' );

SELECT l.lname
FROM   lief l
WHERE  EXISTS ( SELECT FALSE
                FROM   lief lg
                WHERE  l.ware=lg.ware AND
                       lg.lname='Grau' );

........................................................................

SELECT *
FROM   lief l
WHERE  preis <= ALL ( SELECT preis
                      FROM   lief
                      WHERE  ware=l.ware );

SELECT *
FROM   lief l
WHERE  preis < ALL ( SELECT preis
                     FROM   lief
                     WHERE  ware=l.ware );

SELECT *
FROM   lief l
WHERE  0=1;

SELECT *
FROM   lief l
WHERE  preis <= ALL ( SELECT preis
                      FROM   lief
                      WHERE  ware=l.ware ) OR
       preis >= ALL ( SELECT preis
                      FROM   lief
                      WHERE  ware=l.ware );

SELECT *
FROM   lief l
WHERE  TRUE;

........................................................................


SELECT kname, kadr, lname, ladr
FROM   kunde, lief
WHERE  EXISTS ( SELECT *
                FROM   auf
                WHERE  auf.ware=lief.ware AND
                       auf.kname=kunde.kname );

SELECT kname, kadr, lname, ladr
FROM   kunde, lief
WHERE  ware =ANY ( SELECT ware
                   FROM   auf
                   WHERE  kname=kunde.kname );

SELECT kname, kadr, lname, ladr
FROM   kunde, lief
WHERE  kname =ANY ( SELECT kname
                    FROM   auf
                    WHERE  ware=lief.ware );

........................................................................

SELECT lname
FROM   lief l
WHERE  NOT EXISTS ( SELECT ware
                    FROM   lief
                    WHERE  lname='Grau' AND
                           NOT ware IN ( SELECT ware
                                         FROM   lief
                                         WHERE  lname=l.lname ) );

SELECT res.lname
FROM   lief res
WHERE  NOT EXISTS ( SELECT gr.ware
                    FROM   lief gr
                    WHERE  gr.lname='Grau' AND
                           NOT gr.ware IN ( SELECT reswa.ware
                                            FROM   lief reswa
                                            WHERE  reswa.lname=res.lname ) );
--                                        --------------------------------
--                                        Warenmenge des Resultatslieferanten

-- SELECT res.lname                           -- NOT EXISTS F == FORALL NOT F
-- FROM   lief res
-- WHERE  FORALL ( SELECT gr.ware -- FORALL nicht in SQL!
--                 FROM   lief gr
--                 WHERE  NOT [ gr.lname='Grau' AND
--                        NOT gr.ware IN ( SELECT reswa.ware
--                                         FROM   lief reswa
--                                         WHERE  reswa.lname=res.lname ) ] );

-- SELECT res.lname                    -- NOT (F AND G) == (NOT F) OR (NOT G)
-- FROM   lief res                     -- NOT NOT F == F
-- WHERE  FORALL ( SELECT gr.ware -- FORALL nicht in SQL!
--                 FROM   lief gr
--                 WHERE  NOT gr.lname='Grau' OR
--                        gr.ware IN ( SELECT reswa.ware
--                                     FROM   lief reswa
--                                     WHERE  reswa.lname=res.lname ) );

-- SELECT res.lname                              -- NOT F OR G == F IMPLIES G
-- FROM   lief res
-- WHERE  FORALL ( SELECT gr.ware -- FORALL nicht in SQL!
--                 FROM   lief gr
--                 WHERE  gr.lname='Grau' IMPLIES
--                        gr.ware IN ( SELECT reswa.ware
--                                     FROM   lief reswa
--                                     WHERE  reswa.lname=res.lname ) );

--                        alle Grau-Waren tauchen in der Warenmenge des
--                        Resultatslieferanten auf

........................................................................

DELETE FROM lief;

INSERT INTO lief VALUES ('Grau','','A',0);
INSERT INTO lief VALUES ('Grau','','B',0);

INSERT INTO lief VALUES ('Lila','','A',0);
INSERT INTO lief VALUES ('Lila','','B',0);

INSERT INTO lief VALUES ('Pink','','A',0);
INSERT INTO lief VALUES ('Pink','','C',0);

INSERT INTO lief VALUES ('Blau','','A',0);
INSERT INTO lief VALUES ('Blau','','B',0);
INSERT INTO lief VALUES ('Blau','','C',0);

........................................................................

SELECT ware FROM auf
UNION
SELECT ware FROM lief;

------------------------------------------------------------------------

Operationen der Relationalen Algebra in SQL-Beispielanfragen
- Projektion
- Selektion
- Umbenennung
- Produkt
- Vereinigung
- Differenz

SELECT ladr, lname FROM lief;
  project_[ladr,lname](lief)
SELECT * FROM kunde WHERE kto>0;
  select_[kto>0](kunde)
SELECT kname AS custname, kadr AS custadr, kto AS balance FROM kunde;
  rename_[custname<-kname,custadr<-kadr,balance<-kto](kunde)
SELECT * FROM kunde, lief;
  kunde x lief
SELECT kname, kadr FROM kunde UNION SELECT lname, ladr FROM lief;
  project_[kname,kadr](kunde) union project_[lname,ladr](lief)
SELECT ware FROM auf EXCEPT SELECT ware FROM lief;
  project_[ware](ware) - project_[ware](lief)

------------------------------------------------------------------------

Anfragen mit Aggregationsfunktionen und Gruppierung

------------------------------------------------------------------------

Anzahl von Kunden

SELECT COUNT(*) FROM kunde;

SELECT COUNT(kname) FROM kunde;

SELECT COUNT(DISTINCT kname) FROM kunde;

SELECT COUNT(kadr) FROM kunde;

SELECT COUNT(DISTINCT kadr), COUNT(kadr) FROM kunde;

------------------------------------------------------------------------

Summe der Auftragsmengen je Ware

SELECT   ware, SUM(menge)
FROM     auf
GROUP BY ware;

-- INSERT INTO auf VALUES ('Schwarz', 'Mehl',  100);
-- INSERT INTO auf VALUES ('Schwarz', 'Salz',  300);
-- INSERT INTO auf VALUES ('Weiss',   'Mehl',  200);
-- INSERT INTO auf VALUES ('Weiss',   'Salz',  300);
-- INSERT INTO auf VALUES ('Weiss',   'Zucker',500);

------------------------------------------------------------------------

Waren die von mehr als einem Lieferanten angeboten werden

SELECT   ware
FROM     lief
GROUP BY ware
HAVING   COUNT(lname)>1;

formulierbar auch im Kern (ohne Aggregationsfunktionen und Gruppierung)

SELECT DISTINCT ware
FROM   lief l1
WHERE  EXISTS (SELECT *
               FROM   lief l2
               WHERE  l1.ware=l2.ware AND l1.lname<>l2.lname);

ebenfalls einfache Mimimum- und Maximum-Suche im Kern formulierbar

------------------------------------------------------------------------

Anzahl der verschiedenen Lieferanten die Mehl oder Milch anbieten

SELECT COUNT(DISTINCT lname)
FROM   lief
WHERE  ware='Mehl' OR ware='Milch';

i.A. unterschiedlich von

SELECT COUNT(lname)
FROM   lief
WHERE  ware='Mehl' OR ware='Milch';

------------------------------------------------------------------------

Durchschnitt aller Gesamtauftragsmengen von Waren; in SQL (SQL-89,
SQL-92) nicht mit einer Anweisung formulierbar, da Schachtelung von
Aggregationen ausgeschlossen

------------------------------------------------------------------------

Auftraege mit maximaler Menge (ueber eine Unteranfrage)

SELECT kname, ware
FROM   auf a
WHERE  NOT EXISTS(SELECT *
                  FROM   auf
                  WHERE  menge>a.menge);

Auftraege mit maximaler Menge (mit Aggregationsfunktion)

SELECT kname, ware
FROM   auf
WHERE  menge=(SELECT MAX(menge) FROM auf);

------------------------------------------------------------------------

Waren zusammen mit minimalem, durchschnittlichem und maximalem Preis
alphabetisch nach Waren sortiert

SELECT   ware, MIN(preis), AVG(preis), MAX(preis)
FROM     lief
GROUP BY ware
ORDER BY ware;

------------------------------------------------------------------------

Waren deren maximaler Preis um hoechstens 5 Prozent hoeher ist als der
minimale Preis, i.e. Waren mit geringer Preisspanne

SELECT   ware
FROM     lief
GROUP BY ware
HAVING   MAX(preis)<=MIN(preis)*1.05;

------------------------------------------------------------------------

SELECT  *
FROM    auf, lief
WHERE   auf.ware=lief.ware;

SELECT  *
FROM    auf NATURAL JOIN lief;

SELECT  ware, kname, menge, lname, ladr, preis
FROM    auf NATURAL JOIN lief;

SELECT   *
FROM     auf, lief
WHERE    auf.ware=lief.ware;

SELECT   lname, SUM(menge) AS SUMME
FROM     auf, lief
WHERE    auf.ware=lief.ware AND preis>22
GROUP BY lname
HAVING   SUM(menge)>=3
ORDER BY SUMME;

SELECT   Resultatsterme
FROM     Relationen
WHERE    Bedingung an Tupel
GROUP BY Gruppierung
HAVING   Bedingung an Gruppen
ORDER BY Sortierung

Auswertungsreihenfolge
1. FROM, 2. WHERE, 3. GROUP-BY, 4. HAVING, 5. SELECT, 6. ORDER-BY

------------------------------------------------------------------------