Zum Inhalt springen
L

Das Video kommt von YouTube: erst beim Abspielen verbindet sich die Seite mit YouTube (Google).

Das große SQL: SELECT Abfragen Tutorial

Patrick Boekhoven42:31 3.880 Aufrufe veröffentlicht Auf YouTube

Das Wichtigste aus dem Video

Tipp auf eine Zeit – das Video springt genau dorthin.

Transkriptautomatisch erstellt · 274 Zeilen
Herunterladen
  1. In diesem großen Tutorial werden wir uns damit auseinandersetzen, wie ihr mit den SELECT-Abfragen Daten aus eurer Datenbank ziehen könnt. Und das dauert jetzt natürlich etwas, aber ich
  2. garantiere euch, am Ende seid ihr Experten bzw. kriegt die Daten aus eurer Datenbank, die ihr haben wollt. Aber bevor wir überhaupt beginnen können, müssen wir uns erstmal mit
  3. den Grundlagen beschäftigen. Und die Grundlagen schauen wir uns anhand der Hyper-EDV an. Hier handelt es sich um einen kleinen Computerladen, der eine kleine Datenbank besitzt. Und diese
  4. kleine Datenbank besteht aus verschiedenen Tabellen. Diese Tabellen sind später die Grundlage für unsere Abfragen. Und wir schauen uns das Ganze anhand der Tabelle 'Kunde' an.
  5. Diese Tabellen bestehen aus verschiedenen Spalten, die jeweils ein Attribut darstellen, also das, was abgespeichert wird. Ihr seht hier beispielsweise den Namen, den Vornamen und das Geburtsdatum
  6. unserer Kunden. Also, diese einzelnen Attribute speichern wir in unserer Tabelle für jeden Kunden ab. Und neben den Spalten haben wir noch verschiedene Zeilen, die jeweils einen einzelnen
  7. Datensatz repräsentieren. Also, unser 'D' steht beispielsweise für einen einzelnen Datensatz bzw. einen einzelnen Kunden. Und eventuell wollen wir den mit unserer SELECT-Abfrage gerade holen,
  8. aber dazu kommen wir gleich. Jetzt bleiben wir erst noch mal bei den Grundlagen. Und hier ist wichtig, dass jede Tabelle auch einen Primärschlüssel besitzt, also
  9. ein oder mehrere Attribute, die diesen Datensatz zweifelsfrei identifizieren. Stellen wir uns das jetzt mal bei unseren Kunden vor. Da könnten wir theoretisch sagen, Name und Vorname stellen den
  10. Primärschlüssel da, und das würde bei unserem 'Las Siard' wahrscheinlich sogar klappen. Aber bei 'Thomas Müller' könnte das in die Hose gehen, denn es könnte sein, dass es zwei verschiedene
  11. Personen gibt, die 'Thomas Müller' heißen. Und wenn Name und Vorname jetzt zweifelsfrei diesen Datensatz identifizieren sollen und wir haben zweimal die Person 'Thomas Müller', ja,
  12. dann klappt das logischerweise nicht. Deshalb fügen wir noch eine zusätzliche Spalte hinzu, und zwar die Kundennummer. Und die identifiziert dann zweifelsfrei unseren Datensatz bzw. unseren
  13. Kunden. Denn unser 'Lutgar Siard' der kriegt die Kundennummer eins, und die kriegt kein anderer Kunde. Also, wir können somit zweifelsfrei unseren Kunden an
  14. der Stelle identifizieren, und zwar anhand der Kundennummer. Und den Primärschlüssel erkennt ihr daran, dass das Attribut, wie bei 'Kundennummer', hier unterstrichen ist.
  15. So, die Grundlagen sind jetzt gelegt. Das heißt, ihr wisst jetzt über das Wichtigste Bescheid. Und jetzt müsst ihr für euer DBMS, also für Datenbank-Management-System, gucken,
  16. wie ihr die verschiedenen SQL-Befehle absetzt, über die wir jetzt sprechen werden. Bei MySQL funktioniert das z.B. ganz einfach. Ihr klickt hier oben auf SQL, und dann setzt ihr einfach den
  17. Befehl ab. Also, wir brauchen ein SQL-Statement. SQL, das ist unsere Sprache für die Datenbanken. Und wir brauchen jetzt ein Statement, welches uns die Daten aus der Tabelle 'Kunde' holt.
  18. Die Tabellen, über die wir sprechen, die könnt ihr mit dem SQL-Skript, was ich euch unten in der Videobeschreibung verlinke, selber erstellen. Aber nun zurück zu unserem SQL-Statement. Und
  19. unser SQL-Statement, das startet immer mit einem Schlüsselwort. Und damit verstehen wir ein reserviertes Wort, welches dann einen Befehl beinhaltet, den wir dann selber ausführen wollen.
  20. Und mit dem SELECT-Befehl können wir uns Daten aus unserer Datenbank ausgeben lassen. Wir starten mit dem Schlüsselwort 'SELECT', was aussagt, dass jetzt eine Abfrage stattfinden wird,
  21. und dann folgen die Spalten oder die Spalte, die wir ausgeben wollen. Also, wir müssen natürlich nicht alle Daten aus der Datenbank bzw. aus der Tabelle ziehen,
  22. sondern wir entscheiden uns jetzt nur für die Kundennummer, den Namen und den Vornamen. Wir nennen uns unsere Tabelle, die besteht aus diesen verschiedenen Spalten, und hier müssen
  23. wir uns überlegen, welche Spalten brauchen wir wirklich. Kleiner Tipp an der Stelle: Holt euch das, was ihr braucht und nicht mehr, denn alles belastet logischerweise die
  24. Bandbreite ist am Ende begrenzt. Wenn wir uns dann für die einzelnen Spalten entschieden haben, dann trennen wir die Spalten, also die Attribute, durch ein Komma. Also,
  25. wir sehen hier die Kundennummer, wir sehen den Namen und den Vornamen, und diese Attribute sind dann jeweils durch ein Komma voneinander getrennt.
  26. Und unsere Datenbanken, die bestehen in der Regel nicht nur aus einer, sondern aus mehreren Tabellen, und genau das müssen wir natürlich beachten, wenn wir ein SQL-Statement
  27. ausführen. Wir brauchen noch die Information, aus welcher Tabelle wir unsere Daten beziehen sollen, und hier kommt ein weiteres Schlüsselwort ins Spiel, und zwar das Schlüsselwort 'FROM'. Und
  28. hinter dem Schlüsselwort 'FROM' wird jetzt erwartet, dass wir den Namen der Tabelle oder die Tabellen angeben, aus der wir unsere Daten beziehen, und das ist in diesem Fall 'Kunde'.
  29. Jetzt schaut euch das Statement mal ganz genau an, denn ihr seht 'SELECT Kundennummer, Name, Vorname FROM Kunde'. Also, das ist sehr intuitiv, also ähnlich wie ihr sprechen
  30. würdet. Und so ein Statement, das endet immer mit einem Semikolon. So, jetzt haben wir ein fertiges SELECT- bzw. fertiges SQL-Statement, und das Ganze führen wir jetzt mal aus.
  31. Und da gibt's jetzt keine allzu große Überraschung: Wir sehen hier unsere verschiedenen Kunden mit den Attributen der Kundennummer, den Namen und dem Vornamen. Also,
  32. im Prinzip klappt das genauso, wie wir uns das vorgestellt haben. Und bei den paar Datensätzen, die wir jetzt hier vorfinden, ist das Thema Übersichtlichkeit natürlich noch gar kein
  33. Problem. Wenn wir nämlich jetzt nach einem bestimmten Kunden suchen, dann können wir da einfach durchscrollen und sagen, okay, der und der Kunde ist an der und der Stelle.
  34. Aber ihr müsst natürlich damit rechnen, dass ihr eventuell eine Datenbank bzw. also auch eine einzelne Tabelle mit tausenden, zehntausenden oder auch hunderttausenden Datensätzen habt,
  35. und dann wird's natürlich schwierig, wenn ihr da bestimmte Datensätze sucht. Und in unserer Datenbasis, da sehen wir schon, es gibt zwei verschiedene Personen mit dem Vornamen
  36. 'Lutg'. Und wenn wir uns genau diese beiden Datensätze ausgeben lassen wollen, dann brauchen wir Bedingungen bzw. eine Bedingung. In diesem Fall verhält es sich folgendermaßen: Wir haben
  37. gerade über Schlüsselwörter gesprochen, und auch hier haben wir ein reserviertes Schlüsselwort, und das ist das Wort 'WHERE'. Und 'WHERE' nutzen wir hier, wenn wir dahinter noch eine Bedingung
  38. in unser SELECT-Statement einbauen wollen. Und dann folgt die eigentliche Bedingung.Und wir wollen uns jetzt an dieser Stelle alle Kunden ausgeben lassen, die mit Vornamen 'Lutka' heißen.
  39. Und die eigentliche Bedingung lautet dann, damit unsere Datenbank bzw. unser DBMS das versteht: 'Vorname gleich Lutka'. Das bedeutet, wir führen zuerst die SELECT-Abfrage aus und
  40. dann am Ende die Ergebnismenge aus und sagen, wir lassen uns nur die Ergebnisse ausgeben bzw. die Datensätze, wo der Vorname 'Lutka' lautet. Und wenn wir das jetzt mal ausführen lassen,
  41. dann führt das dazu, dass wir nur noch eine Teilmenge unserer vorherigen Datensätze vorfinden bei dieser Abfrage, also nur die beiden Datensätze, wo der Vorname wirklich
  42. 'Lutka' lautet. Und das ist erstmal gut und schön und funktioniert auch alles so. Aber im richtigen Leben wird's oft ein bisschen komplizierter. Denn wir springen jetzt mal zu
  43. unserem kleinen Computerladen zurück, wo sich Lara mit dem folgenden Problem konfrontiert sieht: Sie findet nämlich einen Zettel vor, auf dem steht, dass ein gewisser 'Magk' um Rückruf bittet,
  44. und der Nachname ist leider überhaupt nicht zu erkennen. Das führt dazu, dass wir erstmal herausfinden müssen, um welchen 'Mark' es sich hierbei handelt.
  45. Also, noch mal ganz zurück zum Anfang: Wir haben eine Tabelle 'Kunde', jetzt mit deutlich mehr Datensätzen, also mit deutlich mehr Kunden und mit einem Attribut mehr,
  46. also mit der Telefonnummer. Und folgendes Statement können wir jetzt nutzen, um uns alle Kunden mit dem Vornamen 'Mark' ausgeben zu lassen. Also, das Statement ist
  47. im Prinzip das gleiche, nur dass wir noch die Telefonnummer als Attribut hinzufügen und nicht nach 'Ludger' sondern nach 'Max' suchen als Vorname. Und wenn wir das jetzt mal ausführen,
  48. seht ihr, das klappt wunderbar, also genau wie wir das erwartet haben. Aber die Anzahl der Personen, die 'Mark' heißen, ist ein bisschen hoch, um die jetzt alle
  49. durchzutelefonieren bzw. um jetzt alle zu fragen, ob diese Person jetzt speziell um Rückruf bittet. Und dazu gucken wir uns den Zettel jetzt noch mal an, den Lara entziffern soll. Und bei dem
  50. Gekrakel kann man eventuell erahnen, dass der Nachname mit einem 'N' beginnt. Und das können wir uns zu Nutze machen. In diesem Fall brauchen wir nicht nur eine, sondern wir brauchen mehrere,
  51. aber auch das kriegen wir hin. Und das funktioniert nämlich folgendermaßen: Wir erweitern unser Statement jetzt um die Bedingung 'Nachname like N%',
  52. und das Schlüsselwort 'LIKE' ermöglicht es uns, eine Zeichenfolge zu suchen, wenn wir nicht den kompletten Inhalt der Zelle kennen. Und für diese Übereinstimmung bzw. für diese Überprüfung müssen
  53. wir ein Muster definieren, also ein Muster, was dann auf den Wert dieser Zelle zutrifft. Und hier haben wir das Muster 'N%' definiert, und das Muster gibt jetzt an, dass wir einen Nachnamen
  54. suchen, der mit 'N' beginnt, und dahinter kann stehen, was will. Bedeutet das Prozentzeichen steht für beliebig viele andere Zeichen. Und jeder Nachname, der jetzt mit 'N' beginnt,
  55. der wird von dieser Abfrage betroffen sein bzw. wird jetzt rausgefischt. Wir können natürlich auch das Prozentzeichen nach vorne schieben und sagen, der Nachname soll mit einem 'N' enden."
  56. Das würde auch funktionieren, bringt uns in diesem Fall aber natürlich nicht weiter. Aber euch wird vielleicht aufgefallen sein, dass wir hier zwei Bedingungen haben,
  57. also einmal 'Vorname gleich Mark' und der Nachname muss mit einem 'N' beginnen. An dieser Stelle müssen wir die Bedingungen irgendwie miteinander kombinieren, und das machen wir mit
  58. 'AND' oder für uns 'UND'. Das 'UND' bzw. das 'END' verknüpft jetzt beide Bedingungen so, dass beide Bedingungen zutreffen müssen, wenn wir diesen Datensatz ausgeben wollen. Also heißt,
  59. wir prüfen zuerst, lautet der Vorname 'Mark' und beginnt der Nachname mit einem 'N'. Ihr könnt da stattdessen auch ein 'ODER' reinsetzen, dann würde geprüft werden, lautet der Vorname 'Mark' oder
  60. aber beginnt der Nachname mit einem 'N'. Aber das ist ja logischerweise nicht das, was wir abprüfen wollen, sondern wir wollen ja, dass beide Bedingungen zutreffen. Und dann lassen wir das
  61. mal ausführen, und ihr merkt, die Ergebnismenge, die ist schon stark reduziert worden. Allerdings reicht uns das immer noch nicht, denn die Ergebnismenge ist immer noch deutlich zu groß.
  62. Aber Lara erfährt an der Stelle, dass die Kundennummer einstellig war, und mit der Information kommen wir relativ schnell zum Ziel, wenn wir unser Statement
  63. jetzt noch mal optimieren. Denn wir hängen jetzt noch eine weitere Bedingung dran, und zwar 'Kundennummer kleiner als 10'. Und ihr seht links die Kundennummer,
  64. ihr seht rechts die Zahl 10, und in der Mitte, da seht ihr einen Vergleichsoperator, und der besagt, die Zahl bzw. die Kundennummer muss kleiner als die Zahl 10 sein. Ihr könnt hier mit
  65. kleiner gleich oder größer gleich oder auch gleich arbeiten, da steht euch natürlich frei, nutzt das, was ihr in dieser Situation braucht. Aber ganz wichtig, wir müssen natürlich diese Bedingung
  66. jetzt noch mit den anderen Bedingungen verknüpfen, und auch hier entscheiden wir uns für 'UND', denn wir wollen ja, dass alle drei Bedingungen zutreffen. Wir wollen, dass unser Kunde,
  67. den wir suchen, mit Vornamen 'Mark' heißt, dass der Nachname mit einem 'N' beginnt und dass die Kundennummer kleiner als 10 ist. Denn nur wenn all diese drei Bedingungen zutreffen,
  68. dann finden wir unsere Person, die jetzt wirklich zurückgerufen werden will. So, dann lassen wir das ganze mal ausführen, und wir sehen,
  69. wir haben unseren 'Mark Nitzke', also die Person, die wir gesucht haben. So, dann sind wir auch schon bei Kapitel 3 bzw. bei unserem dritten Themenblock, und jetzt kommen
  70. wir zu den Operatoren. Mit den Operatoren können wir unsere Abfragen noch mal deutlich komplett gestalten. Und Lara, die sich letztes Mal sehr über unsere Hilfe gefreut hat,
  71. braucht die jetzt noch mal, denn sie findet wieder einen Zettel vor, nur diesmal ist das Problem nicht die Schrift bzw. die ist jetzt auch nicht so super, aber das Kernproblem ist,
  72. dass bestimmte Teile nicht zu lesen sind. Also, eine Kundin, die bittet um Rückruf, und es ist klar, dass sich in ihrem Namen ein 'Anna' befindet und dass ihre Kundennummer
  73. irgendwie mit '1' beginnt. Und Lara weiß, dass der Zettel von einer Kollegin stammt, die aktuell mit einer Kundin viel zu tun hat, die 'Hanna' oder 'Anna' heißt. Aber so ganz
  74. sicher ist sie sich nicht mehr. Aber der Hinweis hilft uns natürlich erstmal der ganzen Sache auf die Spur zu kommen. Aber das heißt, wir haben als Information ja zur Verfügung, dass Lara
  75. eine Kundin mit dem Vornamen 'Hanna' mit 'H' oder ohne 'H' sucht oder aber eventuell nur 'Anna', und dass die Kundennummer zwischen 100 und 1999 oder aber zwischen 1000 und 1999 liegen muss.
  76. Fünfstellige Kundennummern gibt es nicht, und man kann, wenn man ganz genau hinguckt, sehen, dass da zumindest noch zwei Zahlen hinter der '1' sind. Aber die genaue Anzahl,
  77. die können wir tatsächlich nur erahnen, und als Grundlage dient uns wie immer die Tabelle 'Kunde'. Und jetzt gucken wir uns das Statement mal an,
  78. mit dem wir uns Schritt für Schritt herantasten bzw. das Statement, was uns helfen soll, diese Kundin zu suchen. Der Start dürfte recht klar sein, also 'SELECT Kundennummer,
  79. Name, Vorname und Telefonnummer vom Kunden'. Da ist jetzt nichts Neues. Aber jetzt erweitern wir unsere Bedingung. Also, wie immer, starten wir mit dem
  80. Schlüsselwort 'WHERE', wenn wir eine Bedingung anfügen wollen. Und jetzt wird's interessant, denn wir prüfen mit 'BETWEEN', liegt die Kundennummer bzw. der Wert zwischen 100 und
  81. 1999. Denn mit dem 'BETWEEN'-Operator können wir prüfen, ob ein Wert zwischen zwei ausgewählten Werten liegt. Aber wir erinnern uns, wir haben gesagt, die Kundennummer liegt entweder zwischen
  82. 100 und 1999 oder aber zwischen 1000 und 1999. Und jetzt brauchen wir noch eine zweite Bedingung, und die Bedingung lautet dann logischerweise: 'Liegt die Kundennummer zwischen 1000 und 1999?'
  83. Und jetzt haben wir wieder, wie ihr das vorhin gesehen habt, zwei verschiedene Bedingungen, die wir verknüpfen müssen. Und diesmal verknüpfen wir diese Bedingung mit einem
  84. 'ODER', denn wir wollen ja prüfen, liegt die Kundennummer entweder zwischen 100 und 1999 oder aber liegt die Kundennummer zwischen 1000 und 1999. Also,
  85. es muss jetzt nur noch eine der beiden Bedingungen zutreffen und nicht mehr beide. Und da war ja noch was: Wir müssen ja noch abprüfen, ob der Vorname entweder 'Anna', 'Hanna'
  86. oder 'Hanna' mit 'H' lautet. Und hier kommt der 'IN'-Operator ins Spiel. Der bewirkt nämlich, dass wir nach mehreren definierten Werten suchen können. Und zwar folgendermaßen: Wir schreiben
  87. hier das Attribut 'Vorname' in diesem Fall hin, und dann folgt der 'IN'-Operator, und dann folgen die definierten Werte, nach denen wir suchen wollen. Also 'Anna', 'Hanna' oder 'Hann' mit 'H'.
  88. Und jetzt haben wir hier natürlich drei verschiedene Bedingungen, die wir irgendwie miteinander verknüpfen müssen. Und an dieser Stelle entscheiden wir uns für den 'UND'-Operator,
  89. also für 'AND'. Und diese Bedingungen, die werden jetzt von links nach rechts ausgewertet. Also, wir haben zuerst die Bedingung 1 und die Bedingung 2, und wir gucken,
  90. trifft eine der beiden Bedingungen zu. Und wenn die Kundennummer zwischen 100 und 1999 liegt oder aber zwischen 1000 und 1999, dann sind wir erstmal noch im Spiel.
  91. Und jetzt muss die dritte Bedingung auch noch zutreffen. Das heißt, wenn eine der ersten beiden Bedingungen zugetroffen ist und die dritte Bedingung, dann haben wir
  92. wahrscheinlich unsere Kundin gefunden. So, dann führen wir das Statement mal aus, und wir sehen, wir haben hier verschiedene Personen bzw. verschiedene Kunden, und all diese Kunden
  93. selber haben eine Kundennummer, die irgendwo im Bereich zwischen 100 und 1999 oder aber zwischen 1000 und 1999 liegt und entweder 'Anna', 'Hanna' oder 'Hann' mit 'H' heißen.
  94. Also, ihr merkt, wir haben uns mit unseren Abfragen schon echt nah daran getastet, und es wird langsam wirklich komplex. Und dann geht's weiter mit Kapitel 4
  95. Und zwar mit 'NOT LIMIT' und 'ORDER BY'. Und hier springen wir wieder zur HyperEDV, wo Lara ein Problem hat. Denn sie hat jetzt einen Auftrag: die fünf teuersten Produkte zu finden,
  96. bei denen es sich nicht um ein Komplettsystem oder einen Laptop handelt. Und jetzt gucken wir uns nicht die Tabelle 'Kunde' an, sondern die Tabelle 'Artikel'. In der Tabelle 'Artikel' finden wir
  97. einerseits die Artikelnummer, den Artikelnamen, den Preis des Artikels und die Kategorie der Artikel wieder. Und bei der Kategorie kann es sich natürlich um Tastaturen oder um Komplettsysteme
  98. oder auch um Laptops handeln. Und die letzten beiden wollen wir natürlich ausschließen. Und dann gucken wir wieder unseren SQL-Befehl an, der beginnt wie immer mit dem 'SELECT'. Also,
  99. wir wollen ja eine Abfrage starten, und wir holen uns die Artikelnummer, den Artikelnamen, den Preis und die Kategorie aus der Tabelle 'Artikel'. Hier dürfte nichts
  100. Neues dabei sein. Und natürlich fügen wir dann wieder eine Bedingung an, also mit 'WHERE'. Und jetzt nutzen wir den 'NOT'-Operator. Der führt dazu, dass das Gegenteil erfüllt sein
  101. muss, damit dieser Datensatz am Ende ausgegeben wird. Also, wir prüfen: Handelt es sich bei der Kategorie nicht um ein Komplettsystem und nicht um einen Laptop? Dann geben wir den Datensatz aus.
  102. Diese Art der Bedingung mit dem 'IN'-Operator, die kennen wir ja aus dem vorherigen Kapitel. Und hier drehen wir das Ganze
  103. einfach nur mit 'NOT' um. Also, wir prüfen jetzt im Endeffekt nur, stimmt dieser Wert nicht mit unserer Liste überein? Und unsere Ergebnismenge, die wollen wir jetzt sortieren.
  104. Und sortieren, das machen wir mit 'ORDER BY'. Und jetzt müssen wir natürlich festlegen, nach welchen Attributen das Ganze sortiert wird. Und wir beginnen hier zuerst einmal mit
  105. dem Preis. Also, das Element mit dem höchsten Preis, das soll zuerst angezeigt werden. Und hinter dem Preis da seht ihr das 'DESC', und das steht für descending. Und das bedeutet,
  106. dass wir das Ganze absteigend sortieren. Also, wir starten mit dem höchsten Preis, und dann folgt der zweithöchste Preis, der dritthöchste Preis und so weiter.
  107. Und dann folgt die Artikelnummer. Also, das bedeutet, wir sortieren zuerst nach dem Preis. Und wenn wir jetzt zwei Artikel haben, die gleich viel kosten,
  108. also wo der Preis gleich ist, dann gucken wir in zweiter Instanz, wie es sich mit der Artikelnummer verhält. Und hier haben wir ein 'ASC' dahinter gesetzt. Das
  109. steht für ascending und bedeutet, wir sortieren unsere Werte jetzt in aufsteigender Reihenfolge. Also, haben wir zwei Artikel, die gleich viel kosten, wird uns zuerst der Artikel mit
  110. der niedrigeren Artikelnummer angezeigt. Und die verschiedenen Attribute, nach denen wir sortieren wollen, die kennen wir natürlich, durch ein Komma voneinander, und dahinter seht ihr noch 'LIMIT'.
  111. Und damit begrenzen wir unsere Ergebnismenge auf insgesamt fünf Datensätze. Denn wir wollen ja nur die fünf teuersten Artikel ausgeben und nicht mehr. Und genau das erreichen wir damit. Also,
  112. wir setzen einfach das Schlüsselwort 'LIMIT' dahinter und dann die Zahl, also die Anzahl der Datensätze, die wir ausgeben lassen wollen. Und dann sind wir auch schon fertig.
  113. So, und dann führen wir das Statement jetzt mal aus, und dann sehen wir die fünf teuersten Artikel. Das sind alles Monitore,
  114. die deutlich über 600 € kosten. Es ist jetzt natürlich möglich, dass es noch einen anderen Artikel gibt, der 699,99 € kostet und auf Platz 6 rangiert, aber kein Artikel, der mehr kostet.
  115. Und das, was wir jetzt gerade gemacht haben, eignet sich super, um die Top 5 oder Top 10 aus einer Tabelle herauszuziehen. Und dann erweitern wir unsere Palette der Befehle
  116. einmal um 'COUNT' und 'DISTINCT'. Und ihr werdet merken, jetzt wird's noch mal ein bisschen komplexer. Denn unser Computerladen, der hat jetzt sein Angebot erweitert und bietet
  117. jetzt verschiedene Dienstleistungen im Bereich der Informationstechnik an. Und diese ganzen Aufträge, die werden natürlich in der Datenbank festgehalten. Der Entscheidend
  118. bzw. wichtig für uns ist jetzt erstmal das Budget. Und Lara hält jetzt in Auftrag, die Anzahl der Projektleiter aufzulisten, die jeweils ein Projekt betreut haben,
  119. wo das Budget bei über 50.000 € lag. Und Grundlage hierfür ist die Tabelle 'Projekt', wo wir einerseits die Projektnummer, den Projektnamen, das Budget selber abspeichern
  120. und den Projektleiter. Beim Projektleiter handelt es sich jetzt allerdings um einen Fremdschlüssel, der auf die Mitarbeiternummer aus der Tabelle 'Mitarbeiter' verweist.
  121. Also, wenn wir beim Projektleiter die 1 eintragen, dann ist damit immer der Patrick Müller gemeint. Und bei der 2, wo logischerweise der Mark Villa. Sondern Statement, was jetzt dazu führt,
  122. dass wir alle Projektleiter ausgeben, die ein Projekt mit einem Budget von über 50.000 € geleitet haben. Das entwickeln wir jetzt, und diesmal Schritt für Schritt. Also,
  123. wir gucken uns jetzt erstmal das Statement an, womit wir alle Projekte ausgeben lassen können, wo das Budget bei über 50.000 € lag.Und zwar mit den Attributen der Projektnummer und dem
  124. Projektleiter. Und da sollte jetzt keine große Überraschung drin sein. Wir haben eine normale SELECT-Abfrage aus der Tabelle 'Projekt', und wir hängen eine Bedingung dran, also mit 'WHERE',
  125. wo das Budget bei über 50.000 € liegt. Und das Ergebnis sollte dann auch keine Überraschung darstellen. Also, wir haben insgesamt drei Projekte, wo das Budget bei über 50.000 € lag.
  126. Und jetzt modifizieren wir unseren Befehl mal etwas. Wir setzen vor dem Projektleiter das Schlüsselwort 'DISTINCT'. Und das 'DISTINCT', das sorgt dafür, dass doppelte Werte eliminiert
  127. werden, also dass jeder Wert nur noch ein einziges Mal vorkommen darf. In der Klammer seht ihr dann den Projektleiter. Also, das Attribut, auf das 'DISTINCT' sich bezieht, ist 'Projektleiter'.
  128. Also, es werden alle doppelten Projektleiter eliminiert. Und wenn ihr euch zurückerinnert: Bei unserer Ausgabe gerade, da kam der Projektleiter mit
  129. der Mitarbeiternummer 3 zweimal vor. Und durch 'DISTINCT' kommt dieser Mitarbeiter dann logischerweise nur einmal vor. Und da wir mit 'DISTINCT' die verschiedenen
  130. Datensätze sozusagen zusammenfassen, können wir, wenn wir verschiedene Projektnummern haben, die natürlich nicht mehr anzeigen lassen. Also, schmeißen wir das Attribut 'Projektnummer'
  131. raus. Denn ihr könnt euch vorstellen, wir haben beispielsweise einen Projektleiter, der jetzt mehrere Projekte geleitet hat, die darunter fallen. Da müssten
  132. wir die Projektnummer natürlich mehrfach auflisten, und das klappt natürlich nicht. So, lassen wir das mal ausführen, und ihr seht, wir haben jetzt die Projektleiter
  133. mit der Mitarbeiternummer 1 und 3, die wir ausgegeben kriegen. Also genau das, was wir erwartet haben. Und wo das hinausläuft, das sehen wir jetzt. Denn wir setzen vor das
  134. 'DISTINCT' jetzt noch mal eine Klammer, und davor 'COUNT'. Und damit zählen wir die Datensätze, die wir jetzt zurückbekommen. Also, wir erwarten natürlich, dass jetzt die Zahl 2 ausgegeben wird.
  135. Denn noch mal von vorne: Wir holen uns zuerst alle Projektleiter, die ein Projekt geleitet haben, wo das Budget bei über 50.000 € lag. Mit 'DISTINCT' sorgen wir dafür,
  136. dass doppelte Datensätze eliminiert werden, also dass jeder Projektleiter nur ein einziges Mal vorkommt. Und mit 'COUNT' zählen wir dann, wie viele Projektleiter wir insgesamt haben,
  137. die ein Projekt betreut haben, wo das Budget bei über 50.000 € lag. Und damit es noch ein bisschen übersichtlicher ist, setzen wir ein 'AS Anzahl der Projekte
  138. mit Budget über 50k' dahinter. Das bedeutet, wir können den Namen der Spalte modifizieren. So, dann führen wir das Ganze einmal aus, und als Ergebnis kriegen wir die Zahl 2. Also
  139. einen einzelnen Datensatz, bzw. genau das, was wir hoffentlich erwartet haben. Also, ihr merkt, wir kriegen damit echt komplexe Ergebnisse hin.
  140. Und jetzt kommen wir zu Kapitel 6, und in Kapitel 6 reden wir über den 'INNER JOIN', also wie wir Tabellen miteinander verbinden. Und ihr merkt, das ist ein ganz zentraler Bestandteil,
  141. wenn wir von Datenbanken reden. Denn wenn ihr eine normalisierte Datenbank vorfindet, da müsst ihr diese Tabellen in der Regel miteinander verbinden, um sinnvolle Daten daraus zu bekommen.
  142. Und wir schauen uns das ganze anhand des 'INNER JOINs' an. Und springen wieder zur HyperEDV, wo Lara eine Liste aller Projekte benötigt. Allerdings benötigt Lara noch zusätzlich den
  143. kompletten Namen der Mitarbeiter, die die Projekte geleitet haben, was es nötig macht, dass wir hier Tabellen miteinander verbinden.
  144. Und wir haben jetzt, damit es verständlicher wird, nur noch eine Teilmenge der Projekte und die Tabelle 'Mitarbeiter'. Und wenn wir einerseits den Namen der Projekte haben wollen und andererseits
  145. den Namen der Mitarbeiter, brauchen wir Daten aus zwei verschiedenen Tabellen. Und diese Verbindung, die erstellen wir nachher über das Attribut 'Projektleiter'.
  146. Denn der Projektleiter referenziert ja die Mitarbeiternummer aus der Tabelle 'Mitarbeiter'. Also, eine Verbindung zwischen den beiden Tabellen haben wir schon,
  147. und die müssen wir jetzt per Statement noch mal realisieren. Und das machen wir folgendermaßen: Wir starten zuerst mal mit einem einfachen SELECT-Statement,
  148. und wir bauen dieses Statement jetzt nach und nach aus. Im ersten Schritt gucken wir uns an, wie wir uns die Projektnummer, den Projektnamen, das Budget und den
  149. Projektleiter aus der Tabelle 'Projekt' holen. Also, hier dürfte nichts Neues dran sein. Wenn wir das Statement jetzt einmal ausführen, sehen wir, es sieht ganz
  150. gut aus. Aber beim Projektleiter steht immer die Zahl der Mitarbeiter, und das ist natürlich nicht besonders effektiv bzw. nicht wünschenswert. Denn wir müssten
  151. jetzt natürlich jedes Mal nachschlagen, wer verbirgt sich hinter der Mitarbeiternummer. Aber zu jedem Problem gibt's eine Lösung. Und die Lösung, die sieht folgendermaßen aus:
  152. Mit dem folgenden SELECT-Statement holen wir uns die Projektnummer, den Projektnamen und das Budget. Und dann holen wir uns den Namen der Projektleiter und den Vornamen der Projektleiter.
  153. Also, hier holen wir uns zwei Attribute aus einer zweiten Tabelle. Und dann geht das Ganze weiter. Also, mit 'FROM Projekt' sagen wir, dass wir erstmal uns die
  154. Sachen aus der Tabelle 'Projekt' holen. Und jetzt wird's spannend, denn jetzt nutzen wir den 'INNER JOIN'. Und dann folgt der Name der zweiten Tabelle,
  155. also mit der wir diese Tabelle verbinden wollen. Und das ist die Tabelle 'Mitarbeiter'. Also, wir haben hier die Schlüsselwörter 'INNER JOIN' benutzt, und 'INNER JOIN' verbindet zwei
  156. Tabellen miteinander und gibt dann am Ende die Datensätze zurück, wo aus diesen Tabellen übereinstimmende Werte gefunden werden. Und diese übereinstimmenden Werte bzw. diese Bedingung für
  157. diese übereinstimmenden Werte, die definieren wir jetzt, und zwar hinter dem Schlüsselwort 'ON'. Und hier geben wir an, dass die Mitarbeiternummer aus der Tabelle 'Mitarbeiter' gleich dem
  158. Projektleiter aus der Tabelle 'Projekt' sein muss. Und wenn wir das Statement jetzt mal ausführen lassen, wird schnell klar, dass wir nur die Datensätze angezeigt bekommen, die eine
  159. Verbindung zueinander haben. Klingt jetzt erstmal ein bisschen kompliziert, ist aber ganz einfach. Denn wir gucken uns nochmal unsere Ausgangslage an: Wir hatten ja einerseits die Tabelle 'Projekt'
  160. und andererseits die Tabelle 'Mitarbeiter'. Und wir geben nur die Datensätze aus, die eine Verbindung zueinander haben. Und bei den ersten Projekten seht ihr,
  161. die werden auch angezeigt, die haben auch einen Projektleiter. Und das letzte Projekt, das hat 'NULL' als Projektleiter, also 'NULL' steht für undefiniert. Und hier wurde kein
  162. Projektleiter zugewiesen, und das Projekt taucht in der Ergebnismenge am Ende auch nicht auf. Und wenn wir jetzt einmal zur Tabelle 'Mitarbeiter' wandern, dann sehen wir,
  163. wir haben hier zwei Mitarbeiter, die Projekte geleitet haben. Und der Rest hat keine Projekte geleitet, und diese Projektleiter tauchen auch in unserer Ergebnismenge am Ende nicht auf. Also,
  164. um das jetzt mal anders zu formulieren... Wir suchen Projekte und Mitarbeiter, die der Schnittmenge entsprechen - Projekte mit einem Projektleiter und Mitarbeiter, die ein Projekt
  165. geleitet haben. Das, was ihr hier seht, ist nicht nur in einer normalisierten Datenbank sinnvoll, sondern lebensnotwendig. Ohne diese Joins, also ohne Verbindung zwischen den verschiedenen
  166. Tabellen, können wir logischerweise keine vernünftigen Daten generieren. Weiter geht es mit Teil 7: dem LEFT JOIN, einer speziellen Unterart des Joins. Wir bleiben bei unserem Auftrag. Wenn
  167. wir uns zurückerinnern, haben wir von unseren vier Projekten in der Datenbank nur drei aufgelistet bekommen. Wenn ihr aufmerksam wart, ist euch aufgefallen, dass ein Projekt fehlte - das letzte
  168. Projekt, das keinen Projektleiter hatte. Lara muss hier also nachbessern und alle Projekte ausgeben, auch die, die keinen Projektleiter haben. Beim INNER JOIN erhalten wir die Schnittmenge aus zwei
  169. Tabellen - alle Projektleiter, die Mitarbeiter haben, und Mitarbeiter, die Projekte geleitet haben. Das führt uns logischerweise nicht zum Ziel, aber der LEFT JOIN bringt uns weiter. Mit
  170. dem LEFT JOIN können wir alle Datensätze aus der linken Tabelle und der Schnittmenge zurückgeben, selbst wenn es auf der linken Seite keine Übereinstimmung gibt. Wir müssen nicht viel
  171. ändern: Wir ersetzen einfach die Schlüsselwörter INNER JOIN durch LEFT JOIN - und das war's schon. Und wenn wir das jetzt ausführen, seht ihr, wir bekommen alle Projekte ausgegeben,
  172. auch das Projekt, welches keinen Projektleiter hat. Das bedeutet, wir können auch die Projekte anzeigen lassen, die keine Verbindung zur rechten Tabelle haben. Nur eine Sache ist hier etwas
  173. anders: Bei dem Namen des Projektleiters und dem Vornamen erhalten wir Platzhalterwerte zurück, da es keinen Projektleiter gibt, also keinen Namen oder Vornamen für dieses
  174. Projekt. Deshalb werden diese mit 'nall' aufgefüllt, also nicht definiert. Unser Projekt erscheint einmal, aber die Werte aus der rechten Seite, die Attributwerte,
  175. werden auf Null gesetzt. Eine kurze Anmerkung: Neben dem LEFT JOIN gibt es auch den RIGHT JOIN, bei dem wir Daten aus der rechten Tabelle holen, auch wenn keine Schnittmenge vorhanden
  176. ist. In diesem Fall wären das die Mitarbeiter, was bedeutet, dass wir auch alle Mitarbeiter ausgeben, die kein Projekt geleitet haben. Aber lasst uns das Statement jetzt mal ausführen, dann wird es
  177. wahrscheinlich klarer. Wir sehen, wir bekommen alle Projekte ausgegeben, die in der Schnittmenge vorhanden sind - also unsere drei Projekte - und zusätzlich alle Mitarbeiter, die ein Projekt
  178. geleitet haben. Das umfasst unsere ersten beiden Mitarbeiter sowie alle weiteren Mitarbeiter, die kein Projekt geleitet haben. Zum Beispiel sehen wir bei Julia Peters,
  179. sie hat kein Projekt geleitet, aber sie wird jetzt trotzdem einmal aufgeführt, und die Attributwerte auf der Seite 'Projekt' - also Projektnummer, Projektname und Budget - sind jeweils mit 'nall'
  180. aufgefüllt. Ihr merkt, das kann unter Umständen schon recht komplex werden. Und jetzt gehen wir noch einen Schritt weiter: Wenn Lara den Auftrag erhält, alle Projekte auszugeben, die keinen
  181. Projektleiter haben - was durchaus realistisch ist - dann müssen wir auf den Antijoin zurückgreifen Also, wir sehen, wir haben ein Projekt, bei dem es darum geht, die Verwaltung neu zu verkabeln,
  182. das keinen Projektleiter hatte, und genau das möchten wir uns ausgeben lassen. Jetzt wechseln wir wieder zu unserem Statement mit dem LEFT JOIN und nehmen noch einmal die Mitarbeiternummer mit
  183. rein. Wenn wir das noch einmal ausführen, sehen wir, wie erwartet, dass wir alle vier Projekte ausgegeben bekommen, auch das Projekt, das keinen Projektleiter hat. Hier sind alle
  184. Attributwerte auf der Seite 'Mitarbeiter' mit 'nall' gefüllt, und genau das machen wir uns jetzt zunutze. Wir geben nur Projekte aus, bei denen die Mitarbeiternummer 'nall' ist,
  185. und dafür fügen wir einfach unserem LEFT JOIN Statement eine Bedingung hinzu. Die Bedingung lautet 'where Mitarbeiternummer ist null', also wir geben nur die Datensätze aus, bei denen die
  186. Mitarbeiternummer 'nall' ist. So, dann lassen wir das mal ausführen, und wir bekommen nur dieses eine Projekt ausgegeben, wo der Wert von Mitarbeiternummer wirklich 'nall' ist. Und wenn
  187. wir uns das jetzt mengenmäßig angucken, sehen wir, dass wir nur den linken Teil ausgeben, also die Projekte, die sich nicht in der Schnittmenge befinden. So, und jetzt verschönern
  188. wir unsere Ausgabe noch ein bisschen. Jetzt geben wir nur die Projektnummer, den Projektnamen und das Budget aus, sodass die 'nall'-Werte gar nicht mehr sichtbar sind. Wenn wir das jetzt ausführen,
  189. sieht das schon deutlich attraktiver aus, und Lara hat damit ihren Auftrag erledigt. Und das Ganze können wir natürlich auch umdrehen. Also, wir können auch den RIGHT JOIN
  190. hier einsetzen, und hier bekommen wir natürlich die Projekte, die einen Projektleiter haben, ausgegeben, und natürlich alle Mitarbeiter und Mitarbeiterinnen, die kein Projekt geleitet haben.
  191. Das möchten wir jetzt ausführen, und ihr seht, links haben wir wieder ganz viele 'nall'-Werte, und auch das machen wir uns jetzt einmal zunutze. Denn jetzt fügen wir auch hier noch eine Bedingung
  192. ein, und zwar, dass wir nur die Datensätze ausgeben, wo die Projektnummer null ist. Und wenn wir das jetzt einmal ausführen, dann bekommen wir alle Mitarbeiter und Mitarbeiterinnen ausgegeben,
  193. die kein Projekt geleitet haben, also mengenmäßig, wie ihr das rechts seht, nur die rechte Seite, also die Mitarbeiter, die sich nicht in der Schnittmenge befinden. Und damit es schöner
  194. aussieht, lassen wir das Ganze noch einmal ohne die Projektnummer, den Projektnamen und das Budget ausführen. Und wenn wir das Statement dann noch einmal absetzen, erhalten wir die
  195. Liste aller Mitarbeiter und Mitarbeiterinnen, die bis jetzt kein Projekt geleitet haben. So, und dann kommen wir zum nächsten großen Thema, und das ist das Kopieren von Datensätzen.
  196. Da springen wir wieder zurück zu Lara, die immer noch ein volles Auftragsbuch hat, und die soll jetzt für alle Projektleiter ermitteln, wie hoch der Gesamtbudget für Projekte war.
  197. Und als Grundlage dienen uns hier weiter in die Tabellen Projekt und Mitarbeiter. Aber jetzt brauchen wir die Group-by-Funktion. Damit können wir Zahlen gruppieren, und damit kann Lara – ihr
  198. könnt euch denken – ihr Problem lösen. Der Datenbestand, vor allem in der Tabelle Projekt, wurde jetzt ein bisschen verändert, damit es gleich ein bisschen klarer wird. Denn wir wollen
  199. am Ende Gruppen bilden. Und zwar die Gruppen nach den Projektleitern, damit wir die Budgets ermitteln können. Und wenn ihr euch jetzt die verschiedenen Projekte anguckt, dann müssen wir
  200. logischerweise das Projekt mit der Nummer 1 und der Nummer 3 einer Gruppe hinzufügen, weil die beiden Projekte haben den gleichen Projektleiter. Und auch die Projekte mit der Projektnummer 2 und
  201. der Projekt Nummer 4 bilden eine Gruppe, denn die haben ebenfalls einen eigenen Projektleiter. Also der Projektleiter mit der Mitarbeiter Nummer 2 und das Projekt mit der Projektnummer 5,
  202. denn dies hat eine Projektleiterin. Damit haben wir schon insgesamt unsere drei Gruppen gebildet, die wir nachher brauchen. So, das war die Theorie, und wie wir das praktisch in SQL zusammenbauen,
  203. das gucken wir uns jetzt erstmal an. bzw. Schauen wir uns erstmal das Statement an, und dann wird's wahrscheinlich gleich klar. Und wir gucken uns zuerst hier den letzten Teil vom Statement an.
  204. Und ihr seht hier 'GROUP BY Projektleiter'. Und das bedeutet, wir fassen die Datensätze nach den Projektleitern und Projektleiterinnen zusammen. Also wir bilden hier Gruppen anhand der
  205. verschiedenen Projektleiter bzw. Projektleiterin. Wie wir das hier farblich mit den verschiedenen Gruppen sehen, die Datensätze mit dem Projekt 1 und 3 werden zusammengefasst, weil die den
  206. gleichen Projektleiter haben. Das Projekt mit der Projektnummer 2 und 4 wird zusammengefasst, weil die den gleichen Projektleiter haben. Und das Projekt mit der Projektnummer 5 steht ganz alleine
  207. da, aber bildet natürlich auch eine Gruppe, weil das ja eine einzelne Projektleiterin hat. So, und jetzt starten wir ganz vorne und select, keine große Überraschung, wir führen eine SELECT-Abfrage
  208. durch, und dann lassen wir uns den Projektleiter ausgeben, bzw. die Projektleiterin bzw. die Mitarbeiternummer. Und das funktioniert auch in der GROUP BY-Funktion, denn logischerweise,
  209. wir gruppieren ja nach den Projektleitern bzw. nach der Projektleiterin, und deshalb können wir auch die Projektleiter bzw. die Mitarbeiternummer ausgeben. Das funktioniert mit dem Projektleit.
  210. Das würde beim Budget nicht funktionieren, denn wenn wir uns jetzt beim Projekt 1 und 3 das Budget anzeigen lassen und wir bilden aus diesen beiden Datensätzen eine Gruppe, dann wüsste die
  211. Datenbank bzw. das DBMS jetzt natürlich nicht, soll ich jetzt die 69.000 ausgeben oder soll ich jetzt die 89 € ausgeben? Keine Ahnung, also ich kann hier tatsächlich nur Datensätze ausgeben,
  212. nachdem ich gruppiert habe, oder wo wir eine Aggregatfunktion drauf gelegt haben. Das ganze kann von DBMS zu DBMS etwas variieren. Also, bei MySQL würde beispielsweise
  213. ein zufälliger Wert ausgegeben werden. Aber ihr seid natürlich auf der sicheren Seite, wenn ihr nach den Werten gruppiert oder aber die Aggregatfunktion nutzt. Jetzt fragt ihr euch
  214. natürlich, Aggregatfunktion? Und dafür gehen wir mal ein Stück weiter nach rechts. Und hier seht ihr 'sum'. Und 'sum' ist eine Aggregatfunktion. Und mit 'sum' selber summieren wir dann die Werte
  215. der einzelnen Budgets auf. Und dann können wir das natürlich ausgeben. Und das Attribut, welches dafür herhält, also in diesem Fall Budget, das schreiben wir natürlich dahinter.
  216. Dann klammern wir, ihr seht, so. Wenn wir bei unserem Projektleiter 1 bleiben und bei diesen beiden Datensätzen, dann würden wir hier die 69.000 € plus die 89 € summieren. Und
  217. dann können wir das auch ausgeben. Und ergeben tut das logischerweise das Gesamtbudget. So, und jetzt wollen wir es nicht zu spannend machen, jetzt führen wir das Ganze einmal aus. Und wir
  218. sehen, der Projektleiter mit der Mitarbeiter Nummer 1, der hat ein Gesamtbudget von 6989 € zur Verfügung gehabt. Der Projektleiter mit der Mitarbeiter Nummer 2, Gesamtbudget von 1544 €.
  219. Und die Mitarbeiterin mit der Mitarbeiter Nummer 3, ein Gesamtbudget von 34499 €. Also, ihr seht, wir lassen uns immer den Projektleiter bzw. die Projektleiterin anzeigen, und wir summieren
  220. das Budget dann jeweils auf. Jetzt haben wir allerdings wieder das alte Problem, dass das mit der Mitarbeiternummer gar nicht so toll aussieht und dass wir natürlich den Mitarbeiternamen bzw.
  221. den Namen und den Vornamen brauchen. Und deswegen machen wir jetzt noch mal ein INNER JOIN mit der Tabelle Mitarbeiter, und unsere Group-by-Funktionen, die müssen wir jetzt noch mal
  222. etwas erweitern. Und wir gruppieren jetzt nicht nur nach dem Projektleiter, sondern gleichzeitig auch nach den Namen und nach dem Vornamen der Mitarbeiter bzw. der Mitarbeiterin. Denn genau
  223. das Gleiche, was wir gerade besprochen haben: Wenn wir uns den Namen und den Vornamen anzeigen lassen wollen, dann müssen wir danach logischerweise auch gruppieren. Und den Namen und den Vornamen, den
  224. lassen wir uns logischerweise anzeigen in unserem SELECT-Statement. Und dann führen wir das Ganze jetzt mal aus. So, und das sieht schon deutlich schicker aus. Wir sind in den Namen und den
  225. Vornamen der Mitarbeiter bzw. der Mitarbeiterin, und wir sehen dahinter das gesamte Budget. Und wir haben jetzt eigentlich eine SELECT-Abfrage, mit der wir wirklich arbeiten können, beziehungsweise
  226. die wirklich vernünftig aussieht. Und wenn wir über die Group-by-Funktion reden, dann müssen wir auch über die 'HAVING'-Klausel sprechen. Und dafür springen wir jetzt wieder zurück zu Lara, denn die
  227. soll alle Projektleiter und Projektleiterinnen ermitteln, die ein gesamtes Budget von über 50.000 € zur Verfügung hatten und dabei mehr als drei Projekte geleitet haben. Und dafür gucken
  228. wir unser Statement von gerade noch mal an. Und in der Tabelle Projekt, da fügen wir jetzt noch ein paar Datensätze hinzu, damit am Ende was rauskommt. Also, wenn wir das Statement mit
  229. dem INNER JOIN jetzt auch mal ausführen lassen, dann erhalten wir folgende Ausgabe. Ihr seht, wir haben ja insgesamt vier Projektleiter bzw. eine Projektleiterin, die verschiedene Projekte
  230. geleitet haben und die ein Budget zur Verfügung hatten. Und wichtig für uns an dieser Stelle ist natürlich nicht nur das gesamte Budget, sondern auch die Anzahl der geleiteten Projekte. Also,
  231. was wir jetzt noch machen, ist, wir ergänzen unser Statement um 'COUNT Proj_Projektleiter'. Der 'COUNT Proj_Projektleiter' macht genau das, was wir brauchen. Wir zählen die Anzahl
  232. der Projektleiter innerhalb unserer Gruppe. Also, wir zählen, wie häufig kommt dieser Projektleiter in dieser Gruppe vor. Und das ist genau das, was wir brauchen, denn damit finden wir die
  233. Anzahl der geleiteten Projekte jeder Gruppe raus. So, und das lassen wir jetzt mal ausführen. Und sehen wir, Patrick und Mark, die haben jeweils vier Projekte geleitet, Julia 3, und der Florian
  234. hat insgesamt nur ein Projekt geleitet. Also heißt, wir wollen in dieser Ergebnismenge noch filtern. Und hier benutzen wir, könnt ihr euch natürlich denken, die 'HAVING'-Klausel.
  235. Denn die 'HAVING'-Klausel ist das Äquivalent zu 'WHERE', wenn es um die GROUP BY-Funktion bzw. um die Aggregatfunktionen geht. Und ihr seht, wir benutzen hier die GROUP BY als auch die
  236. Aggregatfunktion. Und jetzt gucken wir uns zuerst einmal das fertige Statement an. Und dahinter seht ihr das Schlüsselwort 'HAVING' und dann zwei verschiedene Bedingungen. Bedingung Nummer 1
  237. lautet, der Projektleiter oder die Projektleiterin soll insgesamt mehr als drei Projekte geleitet haben. Und ihr seht hier den Alias 'Anzahl Projekte' und das Ganze definieren wir hier oben
  238. mit 'COUNT Projektleiter' als 'Anzahl Projekte'. Also, wir zählen mit 'COUNT', wie häufig kommt dieser Projektleiter oder diese Projektleiterin innerhalb dieser Gruppe vor.Das Gleiche machen
  239. wir bei 'Budget'. Das mit dem Alias, das machen wir bei 'Budget'. Denn wir gucken, hier liegt das gesamte Budget bei über 50.000 €. Und den Alias, den definieren wir hier oben mit 'someproject',
  240. wo wir das Budget dann aufsummieren. Und mit 'S gesamtes Budget' nutzen wir dann wieder den Alias, also den wir unten dann wieder aufgreifen. Und dazwischen setzen wir noch ein 'AND'. Das heißt,
  241. beide Bedingungen müssen zutreffen. Also, die Person muss mehr als drei Projekte geleitet haben, und das gesamte Budget muss bei über 50.000 € liegen. So, und dann lassen wir das Ganze mal
  242. ausführen. Und wir sehen, wir bekommen nur unsere beiden Projektleiter zurückgegeben, die auch wirklich unter diese Kategorie fallen, dass sie einerseits mehr als drei Projekte
  243. geleitet haben und gleichzeitig ein Gesamtbudget von über 50.000 € zur Verfügung hatten. Denn die gute Julia, die hatte weder genug Projekte geleitet, noch hat sie genug Budget zur
  244. Verfügung gehabt. Und der Florian, ja, der hat nur ein Projekt geleitet. Hätte das Kriterium des Budgets zwar erfüllt, aber wir haben jetzt eine 'AND'-Bedingung gesetzt. Also,
  245. beide Bedingungen müssen zutreffen. Deswegen wird Florian ebenfalls nicht mit aufgelistet. Und am Schluss müssen wir uns noch mal über die Aggregatfunktionen unterhalten. Denn
  246. die bieten zwar eine Menge Möglichkeiten, machen das Ganze auch noch mal deutlich komplexer. Und unsere hyperedv, die besteht natürlich nicht nur aus Lara, sondern auch Hannes arbeitet
  247. bei der hyperedv. Und Hannes ist Statistiker und der will wissen, was zahlenmäßig noch so geht. Kleiner Spoiler: Da geht noch eine ganze Menge. Und zwar mit den Aggregatfunktionen.
  248. Der Name der Aggregatfunktion, der kommt aus dem Englischen, also von 'Aggregate'. Und das ganze hat seine Herkunft im Lateinischen und bezeichnet bzw.
  249. bedeutet 'gesammelt' oder 'zusammengefasst'. Und genau das können wir in SQL machen. Wir können verschiedene Werte zusammenfassen und daraus genau einen Ergebniswert bilden. Und
  250. das ist ja vor allem, wenn wir von der GROUP BY-Funktion reden, sinnvoll. Denn wir fassen hier verschiedene Datensätze zusammen und wollen am Ende einen Ergebniswert haben.
  251. Klingt jetzt wieder recht theoretisch, aber wir gucken uns das natürlich wieder praktisch an. Und zwar wieder anhand der Tabellen 'Projekt' und 'Mitarbeiter'. Und wir erinnern uns noch mal
  252. zurück: Wir haben in der Tabelle 'Projekt' ja die Projekte zusammengefasst, die den gleichen Projektleiter bzw. die gleiche Projektleiterin hatten. Und wir erinnern uns noch mal zurück:
  253. Wir hatten dann ja auch die verschiedenen Budgets. Und diese Budgets, die wurden ja in einer Aggregatfunktion zusammengenommen bzw. wir haben ja schon eine Aggregatfunktion genutzt. Und
  254. zwar in dem Moment, wo wir die Budgets aufsummiert haben. Und das Statement, das gucken wir uns jetzt noch mal an. Also, ihr seht hier, dass wir uns nur den Projektleiter und das Budget holen bzw.
  255. das Budget dann aufsummieren. Und damit haben wir die erste Aggregatfunktion auch schon besprochen: Also, mit 'SUM' summieren wir die Werte der festgelegten Spalten auf.
  256. Und das führen wir jetzt mal aus. Und keine Überraschung, wir kriegen hier den Projektleiter bzw. die Mitarbeiternummer und das aufsummierte Budget.
  257. Auf den Join habe ich hier in diesem Teil übrigens verzichtet, wie ihr seht. Und the next one ist 'COUNT'. Und mit 'COUNT' zählen wir, wie häufig dieser Eintrag in einer
  258. Gruppe vorhanden ist. Und bei dem Statement, was wir jetzt einmal um 'COUNT' erweitern, zählen wir, wie häufig dieser Projektleiter oder diese Projektleiterin dann innerhalb
  259. dieser Gruppe vorkommt, bzw. wie viele Projekte dann im Prinzip geleitet hat. So, und auch das führen wir jetzt mal aus. Und wir haben hier drei Spalten:
  260. Projektleiter, das Budget und die Anzahl der Projekte. Und dann erweitern wir unser Statement noch einmal. Und zwar um 'MIN'. Und 'MIN' gibt
  261. den minimalen bzw. den kleinsten Wert aus den ausgewählten Spalten zurück. Das heißt, wir lassen uns damit das niedrigste Budget anzeigen aus den ganzen Projekten,
  262. die diese Mitarbeiter bzw. Mitarbeiterinnen geleitet haben. Und auch das führen wir jetzt mal aus. Und wir sehen eine neue Spalte mit minimalem
  263. Budget. Und wenn wir uns den minimalen Wert ausgeben lassen können, dann können wir uns natürlich auch den maximalen Wert ausgeben lassen. Und das machen wir ja,
  264. könnt ihr euch denken, mit 'MAX'. Und 'MAX' selber gibt dann den maximalen bzw. größten Wert aus den ausgewählten Spalten zurück. Also, hiermit erhalten wir dann das höchste Budget,
  265. was unsere Projektleiter bzw. unsere Projektleiterin zur Verfügung hatten. Und das bauen wir jetzt in unser Statement noch mal ein und lassen das Statement dann einmal
  266. ausführen. Und auch hier bekommen wir an der Stelle die richtige neue Spalte. Also, das hier war maximal alle Budget, was unsere Projektleiter oder Projektleiterin zur Verfügung hatten.
  267. Last, noch least, müssen wir uns noch mit dem Durchschnitt auseinandersetzen. Und den berechnen wir mit 'AVG', also für 'average'. Und wir gucken jetzt,
  268. dass wir mit 'AVG' 'Budget' uns das durchschnittliche Projektbudget unserer Projektleiter bzw. unserer Projektleiterinnen anzeigen lassen.
  269. Und auch das führen wir jetzt mal aus. Und wenn man das Prinzip einmal verstanden hat, gibt's ja wahrscheinlich keine großen Überraschungen mehr. Wir haben jetzt
  270. somit das durchschnittliche Budget aller Projektleiter und Projektleiterinnen. Und wir haben somit wirklich eine aussagekräftige Tabelle bzw. ein aussagekräftiges Ergebnis.
  271. Und vor allem haben wir jetzt eine ganze Menge Kenntnis, was wir mit unseren SELECT-Statements machen können bzw. wie komplex das Ganze werden kann.
  272. So, und damit sind wir auch durch. Hier links, da kommt ihr zu meiner Playlist zum Thema 'relationale Datenbanken'. Wenn euch das alles noch nicht wirklich ein Begriff ist,
  273. schaut auf jeden Fall rein. Und hier rechts, da habe ich meine Playlist zu 'DDL', also zu 'Data Definition Language' verlinkt. Und vor allem vergesst nicht zu
  274. abonnieren und gebt mir gerne einen Daumen nach oben. Alles Gute und bis zum nächsten Mal!

Zum Nachlesen

Join (SQL)Ein SQL-Join (deutsch: Verbund) bildet aus den Datensätzen zweier Tabellen einer relationalen Datenbank eine Ergebnistabelle, deren Datensätze Attribute beider … Selektivität (Informatik)Selektivität ist ein Maß, das in der Informatik bei Datenbankabfragen auf Datenbanktabellen in relationalen Datenbankensystemen gebraucht wird; sie bestimmt … Selektion (Informatik)In der Relationalen Algebra ist die Selektion einer der fünf Operatoren, die in Relationalen Datenbanken eingesetzt werden. Relationale AlgebraIn der Theorie der Datenbanken versteht man unter einer relationalen Algebra oder Relationenalgebra eine Menge von Operationen zur Manipulation von …