Personen haben eine Sozialversicherungsnummer (SVNR), einen Nachnamen (NNAME), und eine Personalnummer (PNR). Außerdem soll der Raum (RAUM) gespeichert werden, in welchem die Person derzeit arbeitet. Sowohl die Personalnummer, als auch die Sozialversicherungsnummer reichen aus um eine Person eindeutig zu identifizieren. Es gibt zwei Arten von Personen, Software Entwickler und Qualitätsmanager. Jede Software ist eindeutig durch eine id (ID) identifiziert. Weiters wird ein Titel (TITEL) festgehalten, und um was für eine Art von Software es sich handelt (TYP). Eine Softwareversion ist eindeutig identifiziert durch die entsprechende Software sowie eine Versionsnummer (VNR). Es muss zu jeder Software jeweils mindestens eine Version existieren. Zu jeder Softwareversion können darüber hinaus eine beliebige Anzahl an Builds existieren. Diese können eindeutig identifiziert werden durch die Softwareversion und eine Buildnummer (BNR). Jede Softwareversion beinhaltet ein oder mehrere Pakete. Zu jedem Paket wird sein Name (NAME), seine Version (VERSION), und die Quelle (QUELLE) woher es stammt gespeichert, wobei der Name und die Version gemeinsam ein Paket eindeutig identifizieren. Darüber hinaus werden die Abhängigkeiten zwischen Paketen vermerkt, also welches Paket welche anderen Pakete als Voraussetzungen benötigt. Ein Paket enthält ein oder mehrere Files, wobei ein File eindeutig identifiziert ist durch das Paket in dem es sich befindet, und seinen Namen (FNAME). Zusätzlich sollen sein Inhalt (INHALT) und der Dateityp (FTYPE) gespeichert werden. Zu manchen Files (jedoch nicht allen) muss außerdem ein Copyright-Vermerk (VERMERK) gespeichert werden. Für Source-Files wird außerdem ihre Länge (LOC) gespeichert, und es ist vermerkt, in welcher Programmiersprache sie verfasst sind. Eine Programmiersprache wird eindeutig identifiziert durch ihren Namen (NAMEN). Es soll außerdem für jeden Software Entwickler gespeichert werden, welche Programmiersprache diese Person beherrscht, und wie gut (LEVEL). Dabei muss jeder Software Entwickler mindestens eine Programmiersprache beherrschen. Zu einem Bugreport soll seine Beschreibung (BESCHREIBUNG) gespeichert werden sowie die Information, wann der Report gemeldet wurde (EINGANG). Jeder Bugreport besitzt außerdem eine eindeutige Tracking Nummer (TRNR), und ist genau einem Build zugeordnet. Bevor ein Bug bearbeitet wird, muss er von einem Qualitätsmanager bestätigt werden. Es soll nicht nur vermerkt werden, wer einen Bug bestätigt hat, sondern auch wann das passiert ist (DATUM). Für behobene Bugreports wird zusätzlich ein Kommentar (KOMMENTAR) vermerkt, sowie von welchem Softwareentwickler der Fehler behoben wurde, und wann (DATUM). Dabei wird jeder Bug von genau einem Entwickler behoben. Zusätzlich kann ein behobener Bug durch maximal einen Qualitätsmanager geprüft werden. Zu jeder Prüfung soll eine (BEWERTUNG) und das Datum (DATUM) der Prüfung gespeichert werden.
1)
Geben Sie eine Lister aller Files (Name und Version des Pakets, Name und Typ des Files) aus, deren Filename mit der Zeichenkette 'index' beginnen. Sortieren Sie die Liste zuerst aufsteigend nach dem Paketnamen, innerhalb des selben Paketnamens absteigend nach der Paketversion, und innerhalb eines Paketes wieder aufsteigend nach den Namen des Files.
SELECT name, version, fname, ftype FROM File WHERE fname LIKE 'index%' ORDER BY name ASC, version DESC, fname ASC;
2)
Geben Sie eine Liste aller Softwareentwickler (Raum und Name) aus die in mindestens 3 Programmiersprachen ein höheres Level als Level 4 haben. Sortieren Sie die Liste zuerst aufsteigend nach dem Raum, und dann absteigend nach dem Namen. Achten Sie darauf, dass für jede Person welche die Eigenschaften erfüllt genau ein Eintrag ausgegeben wird.
SELECT raum, nname FROM SWEntwickler NATURAL JOIN Person NATURAL JOIN beherrscht WHERE LEVEL > 4 GROUP BY svnr, raum, nname HAVING count(name) >= 3 ORDER BY raum ASC, nname DESC;
SELECT raum, nname FROM SWEntwickler NATURAL JOIN Person p WHERE svnr IN ( SELECT b.svnr FROM beherrscht b WHERE p.svnr = b.svnr and b.level > 4 GROUP BY b.svnr HAVING count(*) >= 3 ) ORDER BY raum ASC, nname DESC;
SELECT raum, nname FROM SWEntwickler NATURAL JOIN Person p WHERE 3 <= ( SELECT count(*) FROM beherrscht b WHERE p.svnr = b.svnr and b.level > 4) ORDER BY raum ASC, nname DESC;
3)
Geben Sie die Titel all jener Software aus, zu der es keine Versionsnummer 3 oder höher gibt, jedoch mindestens drei Versionen mit einer Nummer kleiner als 3. Geben Sie zu jeder Software in der Liste außerdem aus, wie viele Versionen es mit einer Versionsnummer kleiner als 3 gibt.
SELECT titel, count(vnr) FROM Version NATURAL JOIN Software GROUP BY id, titel HAVING max(vnr) < 3 AND count(vnr) >= 3;
SELECT titel, count(vnr) FROM Software NATURAL JOIN Version WHERE id NOT IN (SELECT id FROM Version WHERE vnr >= 3) AND vnr < 3 GROUP BY id, titel HAVING COUNT(vnr) >= 3;
SELECT DISTINCT titel, (SELECT count(vnr) FROM version v2 WHERE v2.id=v1.id) FROM Software NATURAL JOIN Version v1 WHERE NOT EXISTS (SELECT * FROM version v2 WHERE VNR >= 3 AND v2.ID = v1.ID) AND 3 <= ( SELECT count(vnr) FROM version v2 WHERE v2.id=v1.id);
4.1)
Geben Sie eine Lister aller bestätigten aber noch nicht behobenen Bugs (TRNR, Beschreibung, Eingang) aus.
SELECT trnr, beschreibung, eingang FROM BugReport NATURAL JOIN (SELECT trnr FROM Bug EXCEPT SELECT trnr FROM BehobenerBug) as openBugs;
SELECT trnr, beschreibung, eingang FROM BugReport NATURAL JOIN Bug EXCEPT (SELECT trnr, beschreibung, eingang FROM BehobenerBug NATURAL JOIN BugReport);
4.2)
Geben Sie jene Builds (Titel der Software, Versionsnummer, Buildnummer) aus, zu denen es seit dem 02.05.2014 (inklusive) die meisten Bug-Reports gibt. (Hinweis: Verwenden Sie die Funktion TO_DATE() mit dem Datumsformat 'DD-MM-YYYY'.)
SELECT titel, vnr, bnr
FROM Build NATURAL JOIN Software NATURAL JOIN BugReport
WHERE eingang >= TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY id, titel, vnr, bnr
HAVING count(trnr) >= all (SELECT count(trnr)
FROM Build NATURAL JOIN BugReport
WHERE eingang >= TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY id, vnr, bnr);
SELECT titel, vnr, bnr
FROM Build NATURAL JOIN Software NATURAL JOIN BugReport
WHERE eingang >= TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY id, titel, vnr, bnr
HAVING count(trnr) = (SELECT max(anz)
FROM (SELECT count(trnr) as anz
FROM Build NATURAL JOIN BugReport
WHERE eingang > TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY id, vnr, bnr) as tmp);
SELECT titel, vnr, bnr
FROM Software NATURAL JOIN BugReport
WHERE eingang >= TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY id, titel, vnr, bnr
HAVING count(trnr) >= all (SELECT count(trnr)
FROM BugReport
WHERE eingang >= TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY id, vnr, bnr);
SELECT titel, vnr, bnr
FROM Software NATURAL JOIN Build b
WHERE (SELECT count(*)
FROM BugReport br
WHERE eingang >= TO_DATE('02-05-2014','DD-MM-YYYY')
AND br.id=b.id AND br.vnr=b.vnr AND br.bnr=b.bnr) =
(SELECT max(anz)
FROM (SELECT count(trnr) as anz
FROM BugReport
WHERE eingang > TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY id, vnr, bnr) as tmp);
SELECT titel, vnr, bnr
FROM Software NATURAL JOIN Build b
WHERE (SELECT count(*)
FROM BugReport br
WHERE eingang >= TO_DATE('02-05-2014','DD-MM-YYYY')
AND br.id=b.id AND br.vnr=b.vnr AND br.bnr=b.bnr) >= all
(SELECT count(trnr) as anz
FROM BugReport
WHERE eingang > TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY id, vnr, bnr);
SELECT titel, b.vnr, b.bnr
FROM (Build NATURAL JOIN Software) b LEFT OUTER JOIN BugReport br
ON (b.id=br.id AND b.vnr=br.vnr AND b.bnr=br.bnr AND eingang >= TO_DATE('02-05-2014','DD-MM-YYYY'))
GROUP BY b.id, titel, b.vnr, b.bnr
HAVING count(trnr) >= all (SELECT count(trnr)
FROM Build NATURAL JOIN BugReport
WHERE eingang >= TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY id, vnr, bnr);
SELECT titel, b.vnr, b.bnr
FROM (Build NATURAL JOIN Software) b LEFT OUTER JOIN BugReport br
ON (b.id=br.id AND b.vnr=br.vnr AND b.bnr=br.bnr)
WHERE eingang >= TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY b.id, titel, b.vnr, b.bnr
HAVING count(trnr) = (SELECT max(anz)
FROM (SELECT count(trnr) as anz
FROM Build NATURAL JOIN BugReport
WHERE eingang > TO_DATE('02-05-2014','DD-MM-YYYY')
GROUP BY id, vnr, bnr) as tmp);
4.3)
Geben Sie jene Versionen (ID der Software und Versionssnummer) aus, von denen mindestens ein Drittel aller Bug-Reports bereits behoben ist. (Beachten Sie, dass dies auch alle Versionen beinhaltet, zu denen es keine Bug-Reports gibt.)
SELECT id, vnr FROM Version WHERE (id,vnr) NOT IN (SELECT id,vnr FROM BugReport) UNION SELECT id, vnr FROM Build b NATURAL JOIN BugReport GROUP BY id, vnr HAVING count(trnr)/3.0 <= (SELECT count(trnr) FROM BugReport b1 NATURAL JOIN BehobenerBug where b.id = b1.id AND b.vnr=b1.vnr);
SELECT id, vnr FROM Version WHERE (id,vnr) NOT IN (SELECT id,vnr FROM BugReport) UNION SELECT id, vnr FROM Version v NATURAL JOIN BugReport GROUP BY id, vnr HAVING count(trnr)/3.0 <= (SELECT count(trnr) FROM BugReport b1 NATURAL JOIN BehobenerBug WHERE v.id = b1.id AND v.vnr=b1.vnr);
SELECT id, vnr FROM Version WHERE (id,vnr) NOT IN (SELECT id,vnr FROM BugReport) UNION SELECT id, vnr FROM Build b NATURAL JOIN BugReport GROUP BY id, vnr HAVING count(trnr)*(1.0/3.0) <= (SELECT count(trnr) FROM BugReport b1 NATURAL JOIN BehobenerBug where b.id = b1.id AND b.vnr=b1.vnr);
SELECT DISTINCT v.id, v.vnr FROM Version v LEFT OUTER JOIN (Build NATURAL JOIN BugReport) bbr ON v.id=bbr.id AND v.vnr=bbr.vnr WHERE bbr.bnr IS NULL OR (SELECT count(*) FROM BehobenerBug NATURAL JOIN BugReport NATURAL JOIN Build b WHERE b.id=v.id AND b.vnr=v.vnr) >= (SELECT count(*) FROM BugReport NATURAL JOIN Build b WHERE b.id=v.id AND b.vnr=v.vnr)/3.0;
SELECT DISTINCT v.id, v.vnr FROM Version v LEFT OUTER JOIN (Build NATURAL JOIN BugReport) bbr ON v.id=bbr.id AND v.vnr=bbr.vnr WHERE bbr.bnr IS NULL OR (SELECT count(*) FROM BehobenerBug NATURAL JOIN BugReport NATURAL JOIN Build b WHERE b.id=v.id AND b.vnr=v.vnr) >= (SELECT count(*) FROM BugReport NATURAL JOIN Build b WHERE b.id=v.id AND b.vnr=v.vnr)*(1.0/3.0);
SELECT DISTINCT v.id, v.vnr FROM Version v LEFT OUTER JOIN BugReport bbr ON v.id=bbr.id AND v.vnr=bbr.vnr WHERE bbr.bnr IS NULL OR (SELECT count(*) FROM BehobenerBug NATURAL JOIN BugReport NATURAL JOIN Version b WHERE b.id=v.id AND b.vnr=v.vnr) >= (SELECT count(*) FROM BugReport NATURAL JOIN Version b WHERE b.id=v.id AND b.vnr=v.vnr)*(1.0/3.0);
SELECT DISTINCT v.id, v.vnr FROM Version v LEFT OUTER JOIN BugReport bbr ON v.id=bbr.id AND v.vnr=bbr.vnr WHERE bbr.bnr IS NULL OR (SELECT count(*) FROM BehobenerBug NATURAL JOIN BugReport NATURAL JOIN Version b WHERE b.id=v.id AND b.vnr=v.vnr) >= (SELECT count(*) FROM BugReport NATURAL JOIN Version b WHERE b.id=v.id AND b.vnr=v.vnr)/3.0;
SELECT DISTINCT v.id, v.vnr FROM Version v LEFT OUTER JOIN BugReport bbr ON v.id=bbr.id AND v.vnr=bbr.vnr WHERE bbr.bnr IS NULL OR (SELECT count(*) FROM BehobenerBug NATURAL JOIN BugReport b WHERE b.id=v.id AND b.vnr=v.vnr) >= (SELECT count(*) FROM BugReport b WHERE b.id=v.id AND b.vnr=v.vnr)/3.0;
5.1)
Geben Sie zu jenen Qualitätsmanagern (pnr, nname, raum) die am meisten Bug-Reports bestätigt haben die Beschreibung der von ihnen bestätigten Bug-Reports aus.
SELECT pnr, nname, raum, beschreibung FROM Person NATURAL JOIN Bug NATURAL JOIN BugReport WHERE svnr in ( SELECT svnr FROM Bug GROUP BY svnr HAVING count(trnr) >= all (SELECT count(trnr) FROM Bug GROUP BY svnr) );
SELECT pnr, nname, raum, beschreibung FROM Person NATURAL JOIN Bug NATURAL JOIN BugReport WHERE svnr in ( SELECT svnr FROM Bug GROUP BY svnr HAVING count(trnr) = (SELECT max(anz) FROM (SELECT count(trnr) as anz FROM Bug GROUP BY svnr) AS tmp) );
5.2)
Geben Sie für alle Bug-Reports (TRNR) ihre Beschreibung aus, sowie den Namen des Qualitätsmanagers der den Bug bestätigt hat. Falls ein Bug-Report noch nicht bestätigt wurde soll statt dem Qualitätsmanager die Zeichenkette "noch nicht bestaetigt" ausgegeben werden. Bei behobenen Bugs soll zusätzlich noch der Kommentar und, falls sie auch schon geprüft wurden, die Bewertung angezeigt werden.Wurde ein Bug-Report noch nicht geprüft soll "noch nicht geprueft" angezeigt werden. Bei noch nicht behobenen Bugs soll an Stelle des Kommentars "offen" ausgegeben werden (und "noch nicht geprueft" an Stelle der Bewertung).
SELECT br.trnr, br.beschreibung, coalesce(qm.nname,'noch nicht bestaetigt') as Manager, coalesce(bbr.kommentar,'offen') as Kommentar, coalesce(g.bewertung,'noch nicht geprueft') as Bewertung FROM BugReport br LEFT OUTER JOIN Bug b ON (br.trnr=b.trnr) LEFT OUTER JOIN Person AS qm ON (b.svnr=qm.svnr) LEFT OUTER JOIN BehobenerBug bbr ON (br.trnr=bbr.trnr) LEFT OUTER JOIN geprueft g ON (br.trnr=g.trnr);
5.3)
Geben Sie eine Liste ALLER Builds aus (Titel der Software, Versionsnummer, Buildnummer) aus mit der Beschreibung der Bug-Reports die seit dem 1.5.2015 eingegangen sind. Falls es für einen Build keinen Bug-Report in dieser Zeitspanne gibt soll "kein aktueller Bug-Report" ausgegeben werden.
SELECT s.titel, b.vnr, b.bnr,
COALESCE(br.beschreibung,'kein aktueller Bug-Report')
FROM Software s NATURAL JOIN Build b LEFT OUTER JOIN BugReport br
ON (b.id = br.id AND b.vnr=br.vnr AND b.bnr=br.bnr AND br.eingang>TO_DATE('01-05-2015','DD-MM-YYYY'));
6.1)
Geben Sie zu all jenen Software-Entwicklern die alle (gespeicherten) Programmiersprachen beherrschen den Nachnamen, den aktuellen Raum sowie für jede Programmiersprache den Level des Entwicklers aus.
SELECT nname, raum, name, level FROM Person p NATURAL JOIN beherrscht WHERE (SELECT count(b.name) FROM beherrscht b WHERE b.svnr=p.svnr)=(SELECT count(name) FROM Programmiersprache);
SELECT nname, raum, name, level FROM (SELECT svnr, nname, raum FROM Person NATURAL JOIN beherrscht b GROUP BY svnr, nname, raum HAVING count(DISTINCT b.name) = (SELECT count(name) FROM Programmiersprache)) as tmp NATURAL JOIN beherrscht;
SELECT p.nname, p.raum, name, level FROM Person p NATURAL JOIN beherrscht WHERE NOT EXISTS ( SELECT name FROM Programmiersprache pr WHERE pr.name NOT IN (SELECT name FROM beherrscht b WHERE p.svnr=b.svnr) );
6.2)
Geben Sie für all jene Software-Entwickler (PNR, Name) die alle (gespeicherten) Programmiersprachen beherrschen und schon mindestens 3 Bugs behoben habe die Anzahl der behobenen Bugs aus.
SELECT pnr, nname, count(trnr) FROM Person NATURAL JOIN BehobenerBug WHERE svnr IN (SELECT svnr FROM Person NATURAL JOIN beherrscht GROUP BY svnr HAVING count(name) = (SELECT count(name) FROM Programmiersprache)) GROUP BY pnr, nname HAVING count(DISTINCT trnr) >= 3;
6.3)
Geben Sie all jene Software-Entwickler (Personalnummer und Name) aus, die alle im Paket 'BasicAI', Version '0.4' verwendeten Programmiersprachen beherrschen (d.h., alle Programmiersprachen zu denen ein entsprechendes Sourcecode File im Paket existiert).
SELECT pnr, nname FROM Person p WHERE (SELECT count(DISTINCT b.name) FROM beherrscht b JOIN Sourcecode s ON (s.prog_name=b.name) WHERE s.name='BasicAI' and s.version=0.4 AND b.svnr=p.svnr)= (SELECT count(DISTINCT prog_name) FROM Sourcecode WHERE name='BasicAI' AND version=0.4);
SELECT pnr, nname FROM Person p WHERE NOT EXISTS (SELECT * FROM Sourcecode WHERE name='BasicAI' AND version=0.4 AND prog_name NOT IN (SELECT name FROM beherrscht b WHERE b.svnr=p.svnr) );
7)
Geben Sie eine Liste jener Builds (ID der Software, Versionsnummer, Buildnummer) aus, von denen alle bestätigten und vor dem 30.09.2013 eingegangenen Bug-Reports bereits behoben wurden. (Hinweis: Verwenden Sie die Funktion TO_DATE() und das Datumsformat '30-09-2013')
SELECT id, vnr, bnr
FROM Build b
WHERE NOT EXISTS (
SELECT *
FROM BugReport br NATURAL JOIN Bug
WHERE br.id=b.id AND br.vnr=b.vnr AND br.bnr=b.bnr AND
eingang<TO_DATE('30-09-2013','DD-MM-YYYY') AND
trnr NOT IN (SELECT trnr FROM BehobenerBug)
);
SELECT b.id, b.vnr, b.bnr
FROM Build b LEFT OUTER JOIN (BugReport NATURAL JOIN Bug) bb ON
( b.id=bb.id AND b.vnr=bb.vnr AND b.bnr=bb.bnr AND eingang<TO_DATE('30-09-2013','DD-MM-YYYY') )
GROUP BY b.id, b.vnr, b.bnr
HAVING COUNT(trnr) = (SELECT count(trnr)
FROM BehobenerBug NATURAL JOIN BugReport br
WHERE br.id=b.id AND br.vnr=b.vnr AND br.bnr=b.bnr AND br.eingang<TO_DATE('30-09-2013','DD-MM-YYYY'));
8)
Geben Sie für JEDE Software (id, Titel) an, wie viele Versionen es von ihr gibt, und wie viele Paketen eine Version im Durchschnitt enthält.
SELECT id, titel, (SELECT count(*) FROM Version v WHERE v.id=s.id) AS Versionen, (SELECT count(*) FROM Version v NATURAL JOIN beinhaltet WHERE v.id=s.id)/ (SELECT count(*) FROM Version v WHERE v.id=s.id) AS "P/V" FROM Software s;
9)
Geben Sie eine Liste aus die für ALLE Software-Entwickler und Qualitätsmanager (Name, Raum, PNR) die Anzahl der verschiedenen von ihnen seit dem 1.1.2015 bearbeiteten Bugs enthält. D.h. für Software-Entwickler soll die Anzahl der behobenen Bugs ausgegeben werden, während für Qualitätsmanger die Anzahl der Bugs ausgegeben werden soll, die sie bestätigt oder geprüft haben, wobei Bugs die von der selben Person bestätigt und geprüft wurden nur einmal gezählt werden soll (HINWEIS: Benützen Sie die Funktion TO_DATE() und das Datumsformat 'DD-MM-YYYY'). Geben Sie in einer weiteren Spalte an, ob es sich bei jeder Person um einen Software-Entwickler oder einen Qualitätsmanger handelt: Bei Softwareentwicklern soll 'SWE' und bei Qualitätsmangern 'QM' ausgegeben werden. Sie dürfen davon ausgehen, dass keine Person gleichzeitig Softwareentwickler und Qualitätsmanger ist.
SELECT nname, raum, pnr, count(trnr) as Bugs, 'SWE' as Typ
FROM (Person NATURAL JOIN SWEntwickler) p LEFT OUTER JOIN BehobenerBug b ON
(p.svnr=b.svnr AND b.datum>=TO_DATE('01-01-2015','DD-MM-YYYY'))
GROUP BY p.svnr, nname, raum, pnr
UNION
(SELECT nname, raum, pnr, count(DISTINCT trnr) as Bugs, 'QM' as Typ
FROM (Person NATURAL JOIN Qualitaetsmanager) p LEFT OUTER JOIN
(SELECT trnr, datum, svnr FROM Bug WHERE datum>=TO_DATE('01-01-2015','DD-MM-YYYY')
UNION
SELECT trnr, datum, svnr FROM geprueft WHERE datum>=TO_DATE('01-01-2015','DD-MM-YYYY')) b
ON b.svnr=p.svnr
GROUP BY p.svnr, nname, raum, pnr);
SELECT nname, raum, pnr, (SELECT count(*) as Bug
FROM BehobenerBug bb
WHERE bb.svnr=p.svnr AND datum>=TO_DATE('01-01-2015','DD-MM-YYYY')),
'SWE' as Typ
FROM Person p NATURAL JOIN SWEntwickler
UNION
(SELECT nname, raum, pnr, (SELECT count(DISTINCT trnr)
FROM (SELECT trnr FROM Bug b
WHERE b.svnr=p.svnr AND
datum>=TO_DATE('01-01-2015','DD-MM-YYYY')
UNION
SELECT trnr FROM geprueft g WHERE g.svnr=p.svnr
AND datum>=TO_DATE('01-01-2015','DD-MM-YYYY')) as tmp) as Bug,
'QM' as Typ
FROM Person p NATURAL JOIN Qualitaetsmanager);
10)
Geben Sie alle Softwareversionen (Titel und Typ der Software, Versionsnummer) aus, welche ein Paket enthalten von dem nicht alle Abhängigkeiten (also vom Paket benötigte Pakete) ebenfalls in der Software enthalten sind. Achten Sie wiederum darauf, dass es für jede betroffene Version genau einen Eintrag gibt.
SELECT titel, typ, vnr FROM Version v NATURAL JOIN Software s WHERE EXISTS (SELECT * FROM beinhaltet b WHERE b.id=v.id AND b.vnr=v.vnr AND EXISTS (SELECT * FROM benoetigt ben WHERE ben.name=b.paketname AND ben.version=b.paketversion AND NOT EXISTS ( SELECT * FROM beinhaltet b2 WHERE b2.id=v.id AND b2.vnr=v.vnr AND b2.paketname=ben.voraussetzung_name AND b2.paketversion=ben.voraussetzung_version))) GROUP BY id, titel, typ, vnr;
SELECT titel, typ, vnr FROM (SELECT DISTINCT id, titel, typ, vnr FROM Version v NATURAL JOIN Software s NATURAL JOIN beinhaltet b WHERE EXISTS (SELECT * FROM benoetigt ben WHERE ben.name=b.paketname AND ben.version=b.paketversion AND NOT EXISTS ( SELECT * FROM beinhaltet b2 WHERE b2.id=v.id AND b2.vnr=v.vnr AND b2.paketname=ben.voraussetzung_name AND b2.paketversion=ben.voraussetzung_version))) as tmp;