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','OL; 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  ware=lief.ware AND
                       kname=kunde.kname );

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;

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

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 h"ochstens 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;

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