SQL as DQL

Watn das?

• Structured Query Language als Data Query Language
• Wir schauen uns heute das "normale" SQL, was alle DBMS sharen an
• Leider können wir nicht alles in Tupeln modellieren
• Dementsprechend schauen wir, das wir das anders (mit joins etc.) modellieren können

Queries

• Mit queries können wir logischerweise Daten abfragen bzw. modifizieren
• Identifizieren tun wir die wie gehabt mit column row und table
• Wir müssen heutezutage nicht mehr alles in Shouty-Case machen, aber das ist gut, um zu spezifizieren was daten(typen) und oder Logikanafragen etc. sind
• Logischerweise können wir alles irgendwie stacken und so sehr komplexe Queries bauen

SELECT-FROM-WHERE

• Das ist die "simpelste" sache die du machen kannst
• Hier fragen wir einfach daten anhand einer Condition ab, nichts wildes, sollte einfach zu verstehen sein

SELECT attribute, list FROM table WHERE condition;

Vergleich zu Relationaler Algebra

WHERE Clause

• hier "passiert" die Condition
• Es gibt verschiedene Conditionale Operatoren
  • Vergleichsoperatoren (Sprich $>,<,\ge ,\le ,=,\ne$ )
  • [not] between x and y
  • [not] like patternX
  • is [not] in listY
  • is [not] distinct from
  • is conditionZ
  • is {[not] true | [not] false}

Matching Strings

• Strings sind immer von '' umgeben
• Ebenso sind sie case-sensitiv
• Um zu suchen können wir wildcards verwenden:
  • % für eine beliebige Anzahl von arbiträren Zeichen
  • _ für genau ein Zeichen
• Diese wildcards können mit anderen Wildcards und Zeichen kombiniert werden
• Diese ggf. kombinierten Queries können dann in einer Query wie SELECT first_name, last_name FROM employee WHERE last_name LIKE %man_; verwendet werden;

Querying Multiple Tables

• Wir können auch mehrere Tabellen gleichzeitig betrachten und Abfragen
• Das machen wir, indem wir mehrere Tabellen zusammenjoinen
  • Joins brauchen ja schon eine (oder mehrere) condition(s) um zusammengeklebt zu werden
  • Relational ausgedrückt sieht das dann so aus:
    $T_1\bowtie \text{ < joinn condition > }{T}_2:=\sigma \text{ < join condition > }(T_1\times T_2)$
  • In SQL sieht das dann So aus:
    SELECT first_name, last_name, address FROM employee, department WHERE department.name = 'Research' AND department.number = employee.department_number;

Renaming

• Manchmal haben wir das problem, dass mehrere Attribute den gleichen Namen haben
• Damit das nicht zu einem Problem wird, können wir dann Tabellen usw. umbenennen
• Das machen wir mit dem as keyword
• Sprich SELECT name as employee_name FROM employee WHERE name = 'Friedrich Wilhelm XXVI';

Multi-Set Operatoren

• 
• Diese Operatoren können verschiedene Formen annehmen, die wir schon aus der Mengenlehre kennen.
  • So kann man z.b. die UNION nehmen, als auch INTERSECT und EXCEPT
  • Wichtig ist hier, den unterschied im Kopf zu behalten, denn sonst kann es lustig werden
• 

Joins

• Mit joins kann man tabellen zusammensetzen
• Das geht mithilfe von Spalten die den gleichen wert haben (sprich Foreign-Key / Primary-Key paare o.ä.)
• Wir können dann so eine RIEEESIIGE Tabelle erschaffen, die dann am ende alles enthält
• Falls man keine Spalte mit den selben Namen und werten hat, kann man mit dem USING operator auch einiges schaffen
• Das sieht dann in etwa so aus: USING (department.number)
• Alternativ gibt es auch noch den ON Operator.
  • Der sieht dann so aus:
    SELECT D.number, E.ssn, E.first_name, E.last_name FROM employee AS E JOIN department AS D ON E.ssn = D.manager_ssn;
• Diesen Operator kann man auch mit einer Condition verbinden, um dann beim Joinen noch auszusortieren.
• Joins kann man übrigens auch auf sich selber ausführen, wobei man dann auf jeden fall die Attribute umbennen muss
• Es gibt bekanntlich auch noch den outer join, aber wo ist denn da der unterschied?

  • The join between two tables, which returns the values of an inner join and the unmatched rows from the left (or right) table, is called left (or right) outer join

  • The join between two tables, which returns the values of an inner join and the results of a left and right outer join, is called a full outer join

• Beim joinen werden leere Werte immer mit NULL aufgefüllt
• 
• 
• 

Doppelte Werte Entfernen: DISTINCT

• Normalerweise passiert das öfter, dass wir doppelte werte haben
• Das ist manchmal nicht ganz so passend, wenn das so ist
• Deswegen klnnen wir dann mit dem DISTINCT Operator identische Tuple bzw. Reihen einfach entfernen
• Syntaktisch wird der Operator einfach hinter SELECT aufgerufen, also: SELECT DISTINCT FROM...

Resultate Sortieren

• Es gibt auch noch den ORDER BY operator
• Damit können wir sachen (wer hätte es gedacht) Sortieren
• Das machen wir mit den datentypen und ner Richtung (ASC für ascending, DESC für decending)

Verschachtelte Queries

• Um richtig Fucked Up Queries zum (rekursiven) Suchen zu basteln können wir mehrer SQL queries ineinander verschachteln
• So können wir z.b. auf das Resultat von einer Query eine weiter ausführen (denn unterm strich ist das resultat einer query immer eine tabelle, nur manchmal ist da halt nur ein einzelner, alleiner, nutzloser und echt blöder Wert drin)
• Falls das nicht das ist, was wir machen wollen, können wir einfach den COMP Operator nutzen um etwas zu VERGLEICHEN (BOAH KRANK HAHAHAHAHAHAHAHHAHAHAHAHAHHAHAHAHAHAHAHAHAHAHAHAHAHAHAHAHHAHAHAHAHAHHAHAHAHAHAHHAHAHAHAHAHAHAHHAHAHAHAHA) (ja, ich hab keine lust mehr)

EXISTS

• Wir können mit EXISTS und NOT EXISTS schauen ob was da ist lol