1 Einführung in SQL Universeller Zugriff auf Daten in Datenbanksystemen unterschiedlicher Systemhersteller!

1

Einführung in SQLEinführung in SQLUniverseller Zugriff auf Daten in Datenbanksystemen unterschiedlicher Systemhersteller!

Dipl.-Ing. Walter Sabin -- 2006 2

SQL – ÜberblickSQL – Überblick Nichtprozedurale Sprache zum Zugriff auf Daten. Herstellerspezifische prozedurale Erweiterungen

– Oracle -> PL/SQL Deklarative Beschreibung der gewünschten Daten Genormt aber doch nicht einheitlich

– z.B.: DB-Verwaltung bei Oracle in SQL integriert Themen:

– Geschichte– SQL - Befehlskategorien– Elementare Datentypen und Operatoren– Einfache Abfragen


GeschichteGeschichte 1974 – SEQUEL (Chamberlin, Boyce)

– Structured English Query Language– basierend auf SQUARE, einer mathematischen

Formelsprache Erster Prototyp: System R – IBM / San Jose

~1975 (Basis für DB2 und SQL/DS)– Wassergekühlter Computer

Erstes Produkt: Oracle – 1979 Version 2!!– PDP 11, Assembler– basiert auf veröffentlichten "System R"

Spezifikationen Derzeit gültiger ANSI Standard – SQL3


Relationale Datenbank (1/3)Relationale Datenbank (1/3)

Definition:– Eine relationale Datenbank ist eine Datenbank, die

aus Sicht des Benutzers aus Tabellen und nur aus Tabellen besteht.

– Relation – mathematischer Ausdruck für Tabelle Atomare Elemente Gesamter Informationsinhalt in Daten Basisarbeit: Dr. E. F. Codd (Codd Father!!)

A Relational Model of Data for Large Shared Data Banks" (Comm. of ACM 1970)



Beispiel:– Lieferanten - Produkte – Versand– 2 Entities mit Relation– Keine "Links" oder "Pointer"– zumindest nicht erkennbar für den Benutzer



Lieferanten: Versand

LNR LNAME STATUS ORT LNRPNR MengeS1 P1 300

S1 Markovitsch 20 Wien S1 P2 200S2 Adam 10 Graz S1 P3 300S3 Schwarz 30 Graz S1 P4 200S4 Pichler 20 Wien S1 P5 100S5 Huber 30 Linz S1 P6 100

S2 P1 300S2 P2 400

Produkte S3 P2 200S4 P2 200

PNR PNAME FARBE GEWICHT S4 P4 300S4 P5 400

P1 Scheibe messing 12P2 Blozen silber 17P3 Schraube kupfer 17P4 Schraube messing 14P5 Haken silber 12P6 Stift messing 19


SQL Befehlskategorien - SQL Befehlskategorien - OracleOracleDML – Data Manipulation Language

– z.B.: SELECT, INSERT, UPDATE, DELETEDDL – Data Definition Language

– z.B.: (CREATE, ALTER, DROP, RENAME) TABLE

Transaktionssteuerung (COMMIT etc.)System- und Session – Steuerung

– z.B.: ALTER SYSTEM


Elementare Datentypen (1/3)Elementare Datentypen (1/3)

Zeichenketten– char(<size>)

z.B.: char(10) feste Größe, rechts mit Leerzeichen aufgefülltmaximal 2000 Zeichen

– varchar2(<size>)z.B.: varchar2(500)variable Länge, maximal 4000 Zeichen



Zahlen– number(<p>,<s>)

z.B.: number(6,2) - 1226.45p: Precission – maximal 38s: Scale – NachkommastellenRundung wenn Anzahl der Nachkommastellen > snegatives "s" möglich - rundet links vom Dezimalpunkt

z.B.: 12345.345 in number(5,-2) ergibt 12300



Datum und Zeit– date

belegt 7 Bytes - CC YY MM DD HH MI SSFunktionen to_date, sysdateDatum ohne Uhrzeit -> Mitternacht (00:00:00)Standard format: DD-MON-YY


Operatoren und Literale (1/2)Operatoren und Literale (1/2)

Operator: manipuliert Datenelemente und liefert ein Ergebnis– unäre Operatoren - <operator><operand>

z.B.: +5 oder –2

– binäre Operatoren - < operand ><operator><operand>

+ - * /

– Verkettungsoperator – verbindet Zeichenketten || - z.B.: 'Oracle' || 'Datenbank' ergibt 'OracleDatenbank'


Operatoren und Literale (2/2)Operatoren und Literale (2/2)

Literale– repräsentieren einen konstanten Wert– Text oder Zeichenketten in einfachen Hochkomma:

'Die Schule ist toll'– Ganze Zahlen (Integer): 24 oder –455– Zahlen (Number) 24.45 oder –433.78 oder 2.3E-4


Einfache Abfragen – SELECT 1/12Einfache Abfragen – SELECT 1/12Allgemeiner Aufbau der Abfrage

– SELECT <attributeList> FROM <relations>WHERE <condition>ORDER BY <orderClause>

Liefert als Ergebnis eine Menge von Datensätzen (Dataset oder Resultset)

Beispieldatenbank - Anhang


Einfache Abfragen – SELECT 2/12Einfache Abfragen – SELECT 2/12

SQL> SELECT * FROM jobs;

JOBID JOB_TITLE MIN_SALARY MAX_SALARY

AD_PRES President 20000 40000

-------

FI_MGR Finance Manager 8200 16000

FI_ACCOUNT Accountant 4200 9000

-------



SQL> SELECT job_title, min_salary FROM jobs;

JOB_TITLE MIN_SALARY

President 20000

-------

Finance Manager 8200

Accountant 4200

-------


Einfache Abfragen – SELECT 4/12Einfache Abfragen – SELECT 4/12 Alias Namen SQL> SELECT job_title AS ‘‘Title‘‘,

min_salary AS "Minimum Salary" FROM jobs;

Title Minimum Salary

President 20000

-------

Finance Manager 8200

Accountant 4200

-------


Einfache Abfragen – SELECT 5/12Einfache Abfragen – SELECT 5/12 Eindeutigkeit der Ergebnismenge sicherstellen SQL> SELECT DISTINCT department_id

FROM employees;

DEPARTMENT_ID

10

20

30

---

100

110

12 rows selected


Einfache Abfragen – SELECT 6/12Einfache Abfragen – SELECT 6/12 Pseudotabelle "dual" SQL> SELECT SYSDATE, USER FROM dual;

SYSDATE USER

20 -NOV-03 HR


Einfache Abfragen – SELECT 7/12Einfache Abfragen – SELECT 7/12 Ergebniszeilen einschränken SQL> SELECT first_name || ' ' || last_name "Name",

department_id FROM employees WHERE department_id=90;

Name DEPARTMENT_ID

Steven King 90

Neena Kochhar 90

Lex De Haan 90

Vergleichsoperatoren= <> (!=, ^=) <, <=, >, >= Logische Operatoren: NOT, AND, OR



Sonstige Operatoren– IN, NOT IN, BETWEEN, EXISTS

SELECT * FROM employees WHERE department_id in (10, 20, 90);

SELECT * FROM employees WHERE salary BETWEEN 5000 and 6000;

SELECT * FROM employees e WHERE EXISTS (SELECT 1 FROM departments d WHERE d.department_id = e.department_id AND d.department_name = 'Administration');



Null Werte– IS NULL, IS NOT NULL

SELECT last_name FROM employees WHERE department_id IS NULL;

LIKE – Pattern-Matching– _, %, Escape clause

_ matched ein einzelnes Zeichen% matched beliebig viele ZeichenEscape Claus erlaubt die Verwendung obiger Zeichen

SELECT * FROM jobs WHERE job_id LIKE 'AC\_%' ESCAPE '\'; WHERE salary BETWEEN 5000 and 6000;


Einfache Abfragen – SELECT 10/12Einfache Abfragen – SELECT 10/12 Sortieren der Ergebniszeilen SQL> SELECT first_name || ' ' || last_name

"Mitarbeiter Name" FROM employeesWHERE department_id=90ORDER BY last_name;

Mitarbeiter Name

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

Lex De Haan

Steven King

Neena Kochar


Einfache Abfragen – SELECT 11/12Einfache Abfragen – SELECT 11/12 Sortieren der Ergebniszeilen mit DISTINCT SQL> SELECT DISTINCT 'Region ' || region_id

FROM hr.countries ORDER BY region_id;ERROR ORA-01791: not a SELECTed expression

SQL> SELECT DISTINCT 'Region ' || region_id FROM hr.countries ORDER BY 'Region ' || region_id;

'Region ' || region_id -------------------------Region 1Region 2Region 3Region 4


Einfache Abfragen – SELECT 12/12Einfache Abfragen – SELECT 12/12 Expressions verwenden z.B.: in SELECT Klausel

– SELECT ((2*4)/(3+1))*10 FROM dual; CASE Expression - "if .. then .. else" Logik

– SELECT country_name, CASE region_id WHEN 1 THEN 'Europa' WHEN 2 THEN 'AMERIKA'WHEN 3 THEN 'Asien' ELSE 'Anderes' END "Kontinent"FROM countries WHERE country_name LIKE 'I%';

COUNTRY_NAME Kontinent

Israel AnderesIndia AsienItaly Europa


QuizQuiz

?


ZusammenfassungZusammenfassung

Geschichte von SQL.Elementare Datentypen und Operatoren.Einfache Abfragebefehle mit

– SELECT, FROM, WHERE und ORDER BY– Operatoren in der WHERE Klause– Pattern-Matching Operatoren


Jemand versucht den Wert: Jemand versucht den Wert: 34567.2255 in ein Feld mit dem 34567.2255 in ein Feld mit dem Datentyp number(7,2) zu speichern. Datentyp number(7,2) zu speichern. Welcher Wert wird tatsächlich Welcher Wert wird tatsächlich gespeichert?gespeichert?

A – 34567.00B – 34567.23C – 34567.22D – 3456.22


Welche Standardanzeigelänge hat ein Welche Standardanzeigelänge hat ein Datumsfeld?Datumsfeld?

A – 8B – 19C – 9D – 6


Gegeben ist die folgende Abfrage:Gegeben ist die folgende Abfrage:SELECT 'Mitarbeiter Name: ' || ename SELECT 'Mitarbeiter Name: ' || ename FROM emp where deptno=10;FROM emp where deptno=10;Welche Komponente ist ein Literal?Welche Komponente ist ein Literal?

A – 10B – enameC – empD – ||


Welche Klause in einer Abfrage Welche Klause in einer Abfrage schränkt die Anzahl der Datensätze schränkt die Anzahl der Datensätze ein?ein?

A – ORDER BYB – SELECTC – FROMD – WHERE


Gegeben ist die folgende Abfrage:Gegeben ist die folgende Abfrage:SELECT empno, ename FROM emp SELECT empno, ename FROM emp where empno=7782 or empno=7876; where empno=7782 or empno=7876; Welcher Operator kann die "OR Welcher Operator kann die "OR Bedingung" ersetzen?Bedingung" ersetzen?

A – INB – BETWEEN .. AND ..C – LIKED – <=


Jemand versucht den Wert: 12345678 Jemand versucht den Wert: 12345678 in ein Feld mit dem Datentyp in ein Feld mit dem Datentyp number(5,-2) zu speichern. number(5,-2) zu speichern. Welcher Wert wird tatsächlich Welcher Wert wird tatsächlich gespeichert?gespeichert?

A – 12345600B – 123456.78C – FehlerD – 123456


Folgende Klauseln können in SQL Folgende Klauseln können in SQL Select statements vorkommen:Select statements vorkommen:1. WHERE1. WHERE2. FROM2. FROM3. ORDER BY3. ORDER BYIn welcher Reihenfolge treten sie auf?In welcher Reihenfolge treten sie auf?

A – 1,3,2B – 2,1,3C – 2,3,1D – Die Reihenfolge ist gleichgültig


FUNKTIONEN FUNKTIONEN „Single Row“ - Funktionen

– Grundlagen– Zeichen Funktionen– Numerische Funktionen– Datums – Funktionen– Konvertierungsfunktionen– Sonstige Funktionen

„Group“ – Funktionen– Grundlagen


FUNKTIONEN Single Row 1/ 16FUNKTIONEN Single Row 1/ 16Verschiedene Datentype als ArgumenteAuch in PL/SQL verwendbarVerwendbar unter anderem in SELECT,

WHERE und ORDER BY KlauselnZ.B.:

– SELECT last_name, TO_CHAR(hire_date, 'Day, DD-MON-YYYY')FROM employees WHERE UPPER(last_name) like 'AL%'ORDER BY soundex(last_name);


FUNKTIONEN Single Row 2/16FUNKTIONEN Single Row 2/16

NULL Werte Funktionen– NVL(Ausdruck1, Ausdruck2)

SELECT last_name, salary salary*commission_pct bonus,(salary+salary*NVL(commission_pct,0)) GehaltFROM employees,

– NVL2(Ausdruck1, Ausdruck2, Ausdruck3)NVL2(commission_pct, salary+salary* commission_pct, salary)



Zeichenfunktionen– ASCII(c1)

liefert den Ascii Wert des ersten Zeichens in c1SELECT ASCII('A') GR_A, ASCII('z') KL_Z FROM dual;

GR_A KL_Z 65 122

– CHR(i)Liefert das Zeichen entsprechend dem Wert i

SELECT CHR(65), chr(122), chr(223) FROM dual;


FUNKTIONEN Single Row 4/ 16FUNKTIONEN Single Row 4/ 16Zeichenfunktionen (Fs)

– INITCAP(c1) liefert den ersten Buchstaben jedes Wortes in c1

als Großbuchstaben und alle anderen als Kleinbuchstaben

SELECT INITCAP('die drei lauser') FROM dual;=> Die Drei Lauser

– LENGTH(c)Liefert Länge einer Zeichenkette in ZeichenSELECT LENGTH('Die Spengergasse') FROM

DUAL;=> 16


FUNKTIONEN Single Row 5/16FUNKTIONEN Single Row 5/16 Zeichenfunktionen (Fs)

– INSTR(c1, c2[,i [,j]]) Liefert die Zeichenposition für das j-te Vorkommen von c2 in c1,

beginnend mit Position i. Negatives i bedeutet Suche von rechts (sonst von links)

SELECT INSTR('Mississippi','i',-2,3) FROM dual;=> 2

– SUBSTR(c1, i[,j]) liefert einen Teilstring aus c1 beginnend an der Position i von j

Zeichen. Ist j < 0 => Rest des Strings. Ist í < 0 => Zählen der Position von rechts.

SELECT SUBSTR('Die Spenger Gasse',5,7) FROM dual;=> Spenger


FUNKTIONEN Single Row 6/ 16FUNKTIONEN Single Row 6/ 16

Zeichenfunktionen (Fs)– LOWER(c1)

Kovertiert alle Zeichen auf Kleinbuchstaben

– UPPER(c1) Konvertiert alle Zeichen auf Großbuchstaben

– SELECT LOWER(job_id), last_name FROM employees WHERE UPPER(last_name) LIKE 'KIN%';=> ad_pres King



Zeichenfunktionen (Fs)– LPAD(c1,i[,c2])

Erweitert den String c1 auf i Zeichen. Verwendet c2 um den freien Raum links aufzufüllen

SELECT LPAD(job_id,10,'.') FROM employees=> ...AD_PRES usw.

– RPAD(c1,i[,c2]) Erweitert den String c1 auf i Zeichen. Verwendet c2 um den

freien Raum rechts aufzufüllen SELECT RPAD(job_id,10,'.') FROM employees

=> AD_PRES... usw.



Zeichenfunktionen (Fs)– LTRIM(c1, c2)

Diese Funktion liefert c1 ohne die führenden Zeichen aus c2. Default: ' '

SELECT LTRIM('Mississippi', 'Mis') FROM dual;=>ppi

– RTRIM(c1,c2)Diese Funktion liefert c1 ohne die nachlaufenden

Zeichen aus c2. Default: ' '



Zeichenfunktionen (Fs)– REPLACE(c1,c2[c3])

Liefert c1 wobei alle Strings c2 durch c3 ersezt werdenSELECT REPLACE('uptown','up','down') FROM dual;

=> downtown

– SOUNDEX(c1)Liefert die phonetische Darstellung von C1SELECT SOUNDEX('Dawes' from dual);

=> D200



Zeichenfunktionen (Fs)– TRANSLATE(c1,c2,c3)

Liefert c1 wobei alle in c1 vorkommenden Zeichen aus c2 durch die der Position in c2 entsprechenden Zeichen aus c3 ersetzt werden.

SELECT TRANSLATE('Mississippi','Mis','mIS') FROM dual; => mISSISSIppI

SELECT translate(KUNDEN.RORT,'ÄÖÜäöüß',chr(142) || chr(153) || chr(154) || chr(132) || chr(148) || chr(129) || chr(225)) RORT FROM KUNDENwhere knr=882;



Numerische Funktionen– ABS(n) – Absolutbetrag von n

– COS, SIN, TAN, ATAN, ASIN, ACOS COSH, SINH Winkelfunktionen

– CEIL(n) – Kleinster ganzzahliger Wert größer oder gleich n SELECT CEIL(9.8), CEIL(-32.85) from dual;=> 10 -32

– FLOOR(n) Größter ganzzahliger Wert kleiner oder gleich n SELECT FLOOR(9.8), FLOOR(-32.85) from dual;=> 9 -33



Numerische Funktionen (Fs)– LN(n) – Natürlicher Logarithmus von n

SELECT LN(2.7) FROM dual;=> 0,993251773010283

– LOG(n1,n2) Liefert den Logarithmus von n1 zur Basis n2 SELECT LOG(27,3) FROM dual;=> 0,333333333333333

– MOD(n1, n2) Liefert n1 modulo n2 SELECT MOD(14,5) FROM dual;=> 4



Numerische Funktionen (Fs)– POWER(n1,n2) – Liefert n1 hoch n2– SQRT(n) – Quadratwurzel aus n– ROUND(n1, n2) – Liefert n1 gerundet auf n2 Stellen– SIGN(n) – liefert 1 falls n pos.-1 falls negativ, 0 wenn 0– TRUNC(n1, n2) – Liefert n1 auf n2 Stellen

abgeschnitten



Datumsfunktionen– ADD_MONTHS(d,i)

Addiert i Monate zu Datum d

– MONTHS_BETWEEN(d1, d2) Liefert die Anzahl der Monate zwischen d1 und d2

– SELECT MONTHS_BETWEEN('19.12.2002','19.03.2002') test from dual;=> 9

– LAST_DAY(d) Liefert den letzten Tag des Monats für das Datum d

– SELECT LAST_DAY(SYSDATE), LAST_DAY(SYSDATE) + 1 from dual;



Datumsfunktionen (Fs)– EXTRACT(c FROM d)

Liefert die durch c angegebene Komponente von d.c: YEAR, MONTH, DAY,HOUR, MIN, SECOND

SELECT EXTRACT(MONTH FROM SYSDATE) FROM dual;=> 1

– TRUNC(d[,fmt])Liefert ein Datum abgeschnitten je nach fmt.

SELECT TRUNC(last_analysed,'HH') FROM user_tables WHERE table_name='TEST_CASE';=> 10-Jan-2003 11:00:00


FUNKTIONEN Single Row 16/16FUNKTIONEN Single Row 16/16 Conversionsfunktionen

– TO_CHAR(x[,fmt]) – x:Datum oder Zahl, fmt: Formatcode SELECT to_char(SYSDATE,'DD-MM-YYYY HH:MI'),

to_char(12.3,'0009.90')=> 13-01-2003 19:35 0012.30

– TO_NUMBER(c[,fmt]) – Liefert Zahl aus String

– TO_DATE(c[,fmt]) – Liefert Datum aus String Sonstige Funktionen

– DECODE(x,m1,r1,m2,r2,....,d) SELECT DECODE(command,0,'None',2,'Insert',3,'Select'...,'Other') cmd

from v$session where type <> 'BACKGROUND';

– LEAST(exp_list), GREATEST(exp_list)


FUNKTIONEN "Group"FUNKTIONEN "Group"

Grundlagen– Aggregat Funktionen – Wert basierend auf

Inputmenge– Vernachlässigt Nullwerte und liefern keine

Nullwerte (Ausnahme: sum bei nur Nullwerten)


FUNKTIONEN "Group" (Fs)FUNKTIONEN "Group" (Fs)

Elementare Funktionen– COUNT {* | [DISTINCT | ALL] x }

Anzahl

– SUM {[DISTINCT | ALL] x } Summe

– MAX {[DISTINCT | ALL] x } Maximalwert

– MIN {[DISTINCT | ALL] x } Minimal

– AVG {[DISTINCT | ALL] x } Durchschnitt


FUNKTIONEN "Group" (Fs)FUNKTIONEN "Group" (Fs) Statement:SELECT employee_id, salary FROM hr.employees WHERE department_id = 60ORDER BY salary;

Ergebnis:EMPLOYEE_ID SALARY

107 4200 105 4800 106 4800 104 6000 103 9000


FUNKTIONEN "Group" (Fs)FUNKTIONEN "Group" (Fs) SELECT AVG(salary) avg, AVG(ALL salary) avg_all, AVG(DISTINCT salary) avg_dist, COUNT(salary) cnt,COUNT(DISTINCT salary) cnt_dist, SUM(salary) sum_all, SUM(DISTINCT salary) sum_dist FROM hr.employees WHERE department_id = 60ORDER BY salary;

Ergebnis avg avg_all avg_dist cnt cnt_dist sum_all sum_dist5760 5760 6000 5 4 28800 24000



Klausel: GROUP BY– Gruppieren von Daten nach einem oder mehreren Kriterien– SELECT department_id, count(*) MA_Anzahl FROM hr.employees GROUP BY department_id;

– Ergebnis: DEPARTMENT_ID MA_ANZAHL DEPARTMENT_ID MA_ANZAHL

10 1 70 1 20 2 80 34 30 6 90 3 40 1 100 6 50 45 110 2 60 5 1



– Klausel: HAVINGEinschränken der zurückgelieferten GruppenKeine Gruppenfunktionen in der where KlauselSELECT department_id DID, sum(salary) SUMSAL, count(*) ANZ FROM hr.employees GROUP BY department_id HAVING count(*) > 10;

Ergebnis:DID SUMSAL ANZ 50 156.400 45 80 304.500 34


Joins und SubqueriesJoins und Subqueries Selektieren von Daten aus mehreren Tabellen FROM Klausel enthält mehrere Tabellenangaben "JOIN" verbindet Datenzeilen aus mehreren

Tabellen Um die Datenmenge zu reduzieren sollten die

Beziehungen zwischen den einzelnen Datensätzen in der where Klausel spezifiziert werden

alternativ kann aoch eine (neue) JOIN Klausel ab Oracle 9i verwendet werden (ISO / ANSI SQL1999)

ohne diese Klauseln -> kartesisches Produkt


Einfache JOINsEinfache JOINs

2 Tabellen und "=" OperatorSELECT locations.location_id, city,

department_nameFROM locations, departmentsWHERElocations.location_id = departments.location_id


Tabellen AliaseTabellen Aliase

temporäres Umbenennen von Tabellen– SELECT l.location_id, city, department_name

FROM locations l, departments dWHERE l.location_id = d.location_idAND country_id != 'US';

mit Schemaname– SELECT locations.location_id, hr.locations.city,

department_name FROM hr.locations, hr.departmentsWHERE location.location_id = departments.location_id;


JOINS – ANSI SyntaxJOINS – ANSI Syntax

NATURAL JOIN– kein Alias möglich

– basiert auf Feldern mit gleichen Namen

– SELECT location_id, city, department_nameFROM locations NATURAL JOIN departments;

– SELECT region_name, country_name, city FROM regions NATURAL JOIN countriesNATURAL JOIN locations;


JOINS – ANSI Syntax Fs.JOINS – ANSI Syntax Fs. JOIN .. USING

– spezifiziert die Felder, die für das JOIN verwendet werden sollen

– SELECT region_name, country_name, city FROM regionsJOIN countries USING (region_id)JOIN locations USING (country_id)

– Fehlerhaft:SELECT region_name, country_name, city FROM regionsJOIN locations USING (country_id)JOIN countries USING (region_id)


JOINS – ANSI Syntax Fs.JOINS – ANSI Syntax Fs.

JOIN .. ON– wenn es keine gemeinsamen Feldnamen gibt– SELECT region_name, country_name, city

FROM regions rJOIN countries c ON r.region_id = c.region_idJOIN locations l ON c.country_id = l.country_idwhere c.country_id = 'US';


Kartesische JOINSKartesische JOINS

verbindet jede Zeile der ersten Tabelle mit jeder Zeile der zweiten Tabelle

möglichst vermeiden – Performance!zumindest immer n-1 JOIN Bedingungen

(n .. Anzahl der Tabellen in der FROM Klausel)

SELECT region_name, country_nameFROM regions, countrieswhere countries.country_ld LIKE 'I%';


OUTER JOINSOUTER JOINS

Liefert alle Werte einer Tabelle auch bei fehlenden Entsprechungen in der zweiten Tabelle

2 Schreibweisen:– Traditionell: (+) zu Feld in der where Klause– ANSI: LEFT JOIN, RIGHT JOIN, FULL JOIN

SELECT c.country_name, l.cityFROM countries c, locations lWHERE c.country_id = l.country_id (+);


OUTER JOINS Fs.OUTER JOINS Fs.

SELECT c.country_name, l.cityFROM countries c, locations lWHERE c.country_id (+) = l.country_id;

SELECT c.country_name, l.cityFROM countries c, LEFT JOIN locations lON c.country_id = l.country_id;

SELECT c.country_name, l.cityFROM countries c, RIGHT JOIN locations lON c.country_id = l.country_id;


OUTER JOIN Fs.OUTER JOIN Fs.

Full OUTER JOIN– neu in Oracle 9i– nur ANSI Syntax möglich– SELECT e.employee_id, e.last_name,

d.department_id, d.department_nameFROM employees eFULL OUTER JOIN departments dON e.department_id = d.department_id;


Andere JOINSAndere JOINS

SELF-Joins– verbindet eine Tabelle mit sich selbst– Beispiel: Liste die Mitarbeiternamen und die

dazugehörigen Managernamen aus der employees Tabelle:

SELECT e.last_name Mitarbeiter, m.last_name ManagerFROM employees e, employees mWHERE m.employee_id = e.manager_id;

ANSI Syntax ???


Andere JOINS FsAndere JOINS Fs

Nicht Gleichheits JOIN– Tabelle grades:

SELECT * FROM grades;GRADE LOW_SALARY HIGH_SALARY P5 0 3000 P4 3001 5000 P3 5001 7000 P2 7001 9000 P1 10001


Andere JOINS FsAndere JOINS Fs

Nicht Gleichheits JOIN Fs– SELECT last_name, salary, grade

FROM employees, gradesWHERE last_name LIKE 'R%'AND salary >= low_salaryAND salary <= NVL(high_salary, salary);

Raphaely 11000 P1Rogers 2900 P5Rajs 3500 P4Russell 14000 P1


Andere JOINS Fs.Andere JOINS Fs. Set – Operatoren

– Kombinieren die Ergebnismengen von zwei Abfragen zu einer Ergebnismenge

– Datentypen und Feldanzahl beider Abfragen sollten übereinstimmen

– Die Namen der Felder aus der ersten Abfrage werden für die Bezeichnung der Ergebnisfelder verwendet

– UNION Liefert alle eindeutigen Datensätze beider Abfragen– UNION ALL liefert alle Datensätze beider Abfragen– INTERSECT Liefert die Datensätze, die in beiden

Abfragen gleich sind– MINUS liefert eindeutige Zeilen der ersten Abfrage

abzüglich der Zeilen der zweiten Abfrage


Andere JOINS Fs.Andere JOINS Fs.

SELECT last_name, hire_date FROM employeesWHERE department_id = 90

UNION

SELECT last_name, hire_date FROM employeesWHERE lastname LIKE 'K%'

(3 Zeilen + 6 Zeilen) ergibt 7 Zeilen


Andere JOINS Fs.Andere JOINS Fs.

Sortierung durch ein! ORDER BY möglichSELECT last_name, hire_date FROM

employeesWHERE department_id = 90UNIONSELECT last_name, hire_date FROM employeesWHERE lastname LIKE 'K%'ORDER BY first_name


Single Row SubqueriesSingle Row Subqueries

Ein Query im QueryLeifert nur einen Datensatz als Ergebnis

– SELECT last_name, first_name, salaryFROM employeesWHERE salary = (SELECT MAX(salary) FROM employees)


Multiple Row SubqueriesMultiple Row Subqueries

Liefern mehr als einen Datensatz vom Subquery

Sicherer wenn die Ergebnismenge nicht sicher ist

SELECT last_name, first_nameFROM employeeswhere department_id in (SELECT department_id FROM employeesWHERE first_name = 'John');


Korrelierte SubqueriesKorrelierte SubqueriesSubquery bezieht sich auf Felder des

MutterqueriesSubquery wird für jeden zurückgelieferten

Datensatz des Mutterqueries ausgeführtSELECT department_id, last_name, salary

FROM employees e1WHERE salary = (select max(salary) FROM employees e2

WHERE e1.department_id = e2.department_id)

ORDER by 1,2,3;


Skalare SubqueriesSkalare Subqueries Liefern genau einen Wert Können an vielen Stellen statt einem Feldwert

verwendet werden Nicht in GROUP BY und HAVING Klauseln in einem CASE Ausdruck:

SELECT city, country_id, (CASE WHENcountry_id in (SELECT country_id FROM countriesWHERE country_name = 'India')THEN 'Indian'ELSE 'NON-Indian'END) "INDIA?"

FROM locations where city LIKE 'B%';


Skalare Subqueries Fs.Skalare Subqueries Fs.

In einer SELECT Klausel– SELECT last_name, department_id,

(select MAX(salary) FROM employees sqWHERE sq.department_id = e.department_id) HiSalFROM employees e WHERE last_name LIKE 'R%';


Skalare Subqueries Fs.Skalare Subqueries Fs.In einer where Klausel

– SELECT department_name, manager_id, (SELECT last_name FROM employees e WHERE e.employee_id = d.manager_id) MGR_NAMEFROM departments dWHERE ((SELECT country_id FROM locations l

WHERE d.location_id = l.location_id) IN (SELECT country_id FROM countries c

WHERE c.country_name = 'United States ..'

OR c.country_name = 'Canada'))AND d.manager_id IS NOT NULL;


DMLDML

Data Manipulation LanguageÄndern von Daten in TabellenKoordinieren von mehrfachen

Veränderungen Verwendung von LocksSteuerung der Änderungen


DML – Modifying DataDML – Modifying Data

INSERT – fügt Datensätze in Tabellen einUPDATE – Ändert Feldwerte in TabellenMERGE – Fügt ein oder ändertDELETE - Löscht DatensätzeSELECT FOR UPDATE – Verhindert

gleichzeitiges Verändern durch andere Transaktionen

LOCK TABLE – Schützt vor gleichzeitiger Veränderung


DML - INSERTDML - INSERT

Fügt Datensätze in ein oder mehrere Tabellen ein

Werte können eingegeben werdenWerte können von Subqueries ermittelt

werden


DML – Single Table INSERTDML – Single Table INSERT

INSERT INTO departments (department_id, department_name, manager_id, location_id)VALUES (280, 'Cash Management', 108,1700)

NULL Werte werden in fehlende Spalten eingefügt


DML – Single Table INSERT Fs.DML – Single Table INSERT Fs.

Folgende Statements sind äquivalent INSERT INTO departments

(department_id, department_name, manager_id, location_id)VALUES (280, 'Cash Management', NULL,1700)

INSERT INTO departments (department_id, department_name, location_id)VALUES (280, 'Cash Management', 1700)


DML – Single Table INSERT Fs.DML – Single Table INSERT Fs.

Verwendung von SubselectsINSERT INTO job_history (employee_id,

start_date, job_id) SELECT employee_id, to_date('01.01.1900','DD.MM.YYYY'), job_id from employees;


DML – Multiple Table INSERTDML – Multiple Table INSERT

Neu in 9iINSERT ALL WHEN Bedingung

THEN Into Klausel ELSE Into Klausel;Verkaufsdaten – Tabelle vkdat:

anr .. Artikelnummer, agr .. Artikelgruppevdat .. Verkaufsdatum, knr .. Kundennr.sq .. Verkaufsmenge, sp .. Verkaufspreisagr: B .. Bücher, V .. Video oder P .. Papier


DML – Multiple Table INSERT Fs.DML – Multiple Table INSERT Fs.

Tabellen: vkbuch, vkvideo, vkpapierAllg. Felder anr, vdat, knr, ums Spezielle Felder

vkbuch: isbn,vkvideo: ej -- Erscheinungsjahr,vkpapier: atyp -- Artikeltyp


DML – Multiple Table INSERT Fs.DML – Multiple Table INSERT Fs.INSERT ALLWHEN agr='B' THEN

INTO vkbuch (anr, vdat, knr, ums) VALUES (anr, vdat, knr, u)WHEN agr='V' THEN INTO vkvideo (anr, vdat, knr, ums) VALUES (anr, vdat, knr, u)WHEN agr='P' THEN INTO vkpapier (anr, vdat, knr, ums) VALUES (anr, vdat, knr, u)SELECT agr, vdat, knr, sp*sq u FROM vkdat


DML - UPDATEDML - UPDATE

Modifiziert vorhandene Datensätze in einer Tabelle

UPDATE tabellennameset (Felder, ...) = (subquery)WHERE Bedingung

UPDATE tabellennameset Feld1 = Wert1, Feld2 = Wert2 ... WHERE Bedingung


DML - UPDATE Fs.DML - UPDATE Fs.

UPDATE employees SET commission_pct = 0.01 WHERE commission_pct is NULL;

UPDATE employeesSET salary = salary*0.15, commission_pct = 0.2WHERE department_id = 60;


DML - UPDATE Fs.DML - UPDATE Fs.

UPDATE job_history j SET start_date = (SELECT hire_date FROM employees e WHERE e.employee_id=j.employee_id)WHERE NOT EXISTS (select * from job_history j2 where j2.end_date is not null and j.employee_id = j2.employee_id);


DML - UPDATE Fs.DML - UPDATE Fs. UPDATE job_history j1

SET start_date = (SELECT end_date + 1 FROM job_history j2WHERE j2.end_date is not NULL andj2.employee_id = j1.employee_id andj2.end_date = (select max(j3.end_date)FROM job_history j3 WHERE j3.end_date is not NULL and j3.employee_id = j2.employee_id))WHERE j1.end_date is NULL and exists (SELECT * from job_history j4 where j4.employee_id=j1.employee_id and j4.end_date is not NULL)


DML - MERGEDML - MERGE MERGE INTO tabelle

USING {tabelle | subquery | view}ON (bedingung) WHEN MATCHED THEN UPDATE SET ... WHEN NOT MATCHED THEN INSERT ... VALUES ( ... );

select * from piP_IDC_IDL_P M_P298633 135 121316333 35 29316533 40 34316433 40 35316633 40 32


DML - MERGE Fs.DML - MERGE Fs. select * from np;

P_ID L_P M_P 2986 135 1113163 40 323164 40 35

merge into pi piusing (select p_id, l_p, m_p from np) npon (pi.p_id = np.p_id)when matched then update set pi.l_p = np.l_p, pi.m_p = np.m_pwhen not matched then insert (pi.p_id, pi.c_id, pi.l_p, pi.m_p)values (np.p_id, 33, np.l_id, np.m_p);


DML - MERGE Fs.DML - MERGE Fs.

Ergebnis:select * from pi;P_ID C_ID L_P M_P2986 33 135 1113163 33 40 323165 33 40 343164 33 40 35


DML - DELETE - TRUNCATEDML - DELETE - TRUNCATE

DELETE FROM table WHERE bedingungDELETE FROM employees WHERE

salary > 15000;Löschen der gesamten Tabelle ohne

RollbackTRUNCATE table [DROP | REUSE]

STORAGE schnell, benötigt wenig Resourcen


DML - LOCKINGDML - LOCKING

SELECT .... FOR UPDATE SELECT * from employees WHERE

NVL(commission_pct,0) > 0 FOR UPDATE; Sperren gesamter Tabelle LOCK table IN lockmode

lockmode: EXCLUSIVE MODE ... queries erlaubt, alles andere nicht SHARE MODE ... verhindert Updates ROW SHARE MODE .. verhindert exclusiven LOCK


DML - TransaktionskontrolleDML - Transaktionskontrolle

COMMIT – Beendet Transaktion

– Änderungen werden permanent

– Änderungen werden sichtbar ROLLBACK

– Alle Änderungen (außer DDL) werden zurückgesetzt SAVEPOINT Name Setzt eine benannte Marke ROLLBACK TO SAVEPOINT

– Setzt bis zur benannten Marke wieder zurück


TABELLEN - DatentypenTABELLEN - Datentypen

Zeichen:CHAR(2000 Zeichen), VARCHAR2(4000 Zeichen), CLOB(4GB), LONG(2GB - alt)

Numerische Datentypen:NUMBER[ (<precision> [,<scale])]kann für alle numerischen Daten verwendet werden

DATUMDATE – Datum und Zeit (bis Sekunden)TIMESTAMP – Datum und Zeit (bis 9 stellige Sekundenbruchteile)


TABELLEN - Datentypen Fs.TABELLEN - Datentypen Fs.

Binäre DatentypenRAW (2000 Byte), BLOB (bis 4GB),BFILE(external FILE bis 4GB)

Sonstige DatentypenROWID – Pseudospalte bei jeder Tabelle(physische Datensatzadresse – schnellster Zugriffsweg, kann sich bei update ändern)


TABELLEN - ErstellenTABELLEN - Erstellen

CREATE TABLECREATE TABLE produkte

( produkt_id NUMBER (4), produkt_name VARCHAR2(50), lager_menge NUMBER(15), preis NUMBER(15,2));


TABELLEN - Erstellen Fs.TABELLEN - Erstellen Fs.

Zusatzinformation beim Erstellen von Tabellen:– Standardwerte– "Constraints"– Tabellenart– Speicherangaben– "Tablespace"– "Partitionierungs" – Information



Namen von Tabellen und Feldern: maximal 30 Zeichen lang

Alphanumerische Zeichen + "_, $, #" erlaubt (beginnend mit Aplhabetischem Zeichen

Caseinsensitiv wenn nicht in "" eingeschlossen



CREATE TABLE auftraege (auftrags_nummer NUMBER(8),status VARCHAR2(10)

DEFAULT 'PENDING');INSERT INTO auftraege (auftrags_nummer)

VALUES (4004);SELECT * FROM ORDERS;

AUFTRAGS_NUMMER STATUS 4004 PENDING


TABELLEN - Erstellen Fs.TABELLEN - Erstellen Fs.NULL Werte unterdrücken - Constraints CREATE TABLE JOB_HISTORY ( EMPLOYEE_ID NUMBER (6) CONSTRAINT JHIST_EMPLOYEE_NN NOT NULL, START_DATE DATE CONSTRAINT JHIST_START_DATE_NN NOT NULL,

END_DATE DATE, JOB_ID VARCHAR2 (10), DEPARTMENT_ID NUMBER (4), CONSTRAINT JHIST_DATE_INTERVAL CHECK (end_date > start_date), CONSTRAINT JHIST_EMP_ID_ST_DATE_PK PRIMARY KEY ( EMPLOYEE_ID, START_DATE ) ) ;


TABELLEN - Erstellen TABELLEN - Erstellen Fs.Fs. Erstellen einer Tabelle aus einer anderen Tabelle

CREATE TABLE emp2 AS SELECT * FROM EMPLOYEES– leere Tabelle wenn Query keine Datensätze liefert

– Alias Namen für neue Feldnamen– Nur "NOT NULL" constraint wird kopiert andere constraints nicht


TABELLEN - VerändernTABELLEN - Verändern Felder hinzufügen

– ALTER TABLE employees ADD city VARCHAR2(30); Felddatentypen verändern

– ALTER TABLE departments MODIFY department_id NUMBER(12);

Felder löschen– ALTER TABLE employees DROP COLUMN city;

TABELLEN löschen– DROP TABLE emp2;

TABELLEN umbenennen– RENAME emp2 TO employees_save

DESCRIBE Tabellenname– listet alle Felder einer Tabelle


CONSTRAINTSCONSTRAINTS NOT NULL

– CREATE TABLE orders ( order_num Number (4) CONSTRAINT nn_order NOT NULL, order_date DATE NOT NULL, product_id NUMBER(14));

Check Constraints– CREATE TABLE bonus ( emp_id VARCHAR2 (40) NOT NULL, salary NUMBER (13,2), bonus NUMBER(13,2), CONSTRAINT ck_bonus CHECK (bonus > 0))


CONSTRAINTS Fs.CONSTRAINTS Fs.

UNIQUE Constraints– Definition auf Feldebene (Einzelfeld) oder Tabellenebene (mehrere Felder)

– ALTER TABLE employees ADD ssn VARCHAR2(11) CONSTRAINT uk_ssn UNIQUE;

– ALTER TABLE employees ADD CONSTRAINT uk_name UNIQUE (first_name, last_name);

– Erstellt automatisch einen Index– Erlaubt Nullwerte



PRIMARY KEY Constraints– Erlaubt keine Nullwerte– Nur ein PRIMARY KEY je Tabelle– Definition auf Feldebene (Einzelfeld) oder Tabellenebene (mehrere Felder)

– Kann nicht mehr gelöscht werden– CREATE TABLE EMPLOYEES ( EMPLOYEE_ID NUMBER (6) NOT NULL,FIRST_NAME VARCHAR2 (20), .... DEPARTMENT_ID NUMBER (4), CONSTRAINT EMP_EMP_ID_PK PRIMARY KEY ( EMPLOYEE_ID ) ) ;


CONSTRAINTS Fs.CONSTRAINTS Fs. FOREIGN KEYS

– Erlaubt Nullwerte– Der referenzierte Key muß der Primary Key oder ein Unique Key in der referenzierten Tabelle sein

– Definition auf Feldebene (Einzelfeld) oder Tabellenebene (mehrere Felder)

– Die Datentypen der Eltern und Kind Tabelle sollten übereinstimmen

– ALTER TABLE EMPLOYEES ADD CONSTRAINT EMP_DEPT_FK FOREIGN KEY (DEPARTMENT_ID) REFERENCES HR.DEPARTMENTS (DEPARTMENT_ID) ON DELETE SET NULL ;

– [ON DELETE {CASCADE | SET NULL}



Constraints können enabled und disabled werden– ALTER TABLE EMPLOYEES DISABLE CONSTRAINT EMP_DEPT_FK;

– ALTER TABLE departments DIABLE PRIMARY KEY CASCADE;

– DEFERRABLE – prüfbar mit Transaktionsende

bei ADD CONSTRAINT (nicht ALTER TABLE)

– INITIALLY {DEFERRED | IMMEDIATE} auch mit ALTER TABLE möglich


Andere DatenbankobjekteAndere Datenbankobjekte

SEQUENCES– CREATE SEQUENCE emp_seq START WITH 1000 INCREMENT BY 10

– DROP SEQUENCE emp_seq– SELECT empseq.nextval FROM emp_seq

– Änderung erfolgt außerhalb von Transaktionen


SYNONYMESYNONYME

CREATE [PUBLIC] SYNONYM synonym_name FOR object– CREATE PUBLIC SYNONYM employees FOR hr.employees;

CREATE TABLE my_emp AS SELECT * FROM EMPLOYEES;ALTER TABLE my_emp add home_phone VARCHAR2(10);CREATE SYNONYM employees FOR my_emp;


INDEXEINDEXE Lesen von Datensätzen

– mittels ROWID– mittels "full table scan"

B_Tree Index oder Bitmap Index– Beide bilden Feldwerte auf ROWIDs ab

Indexe können SELECT DELETE und UPDATE Befehle beschleunigen

Ein Index kann verwendet werden, falls das "führende Subset" des INDEX in der SELECT oder WHERE Klause vorkommt.

Fallweise kann auch ausschließlich der Index ohne die Tabelle verwendet werden


INDEXE Fs.INDEXE Fs.

SELECT count(*) from employees where last_name='Taylor';

Performance für DML Befehle kann verschlechtert werden– Index muß zusätzlich zur Tabelle geändert werden

B-Tree Indexe– gebräuchlichster Index– gut für Felder mit "hoher Kardinalität" (Felder mit vielen unterschiedlichen Werten z.B.: last_name)


INDEXE Fs.INDEXE Fs.

B-Tree Fs.– meist verwendet wenn weniger als 10% der Datensätze gesucht werden.

– Besteht aus "Zweigen" und "Blättern" Zweige enthalten den KEY und die Adresse des Indexblockes auf der nächsten Ebene

Blätter enthalten den Key und die ROWID des Datensatzes

Blätter sind zusätzlich doppelt verlinkt – Warum?

– Verwendung bei führenden Feldern


INDEXE Fs.INDEXE Fs.BITMAP Index

– hauptsächlich bei Datawarehouses verwendet

– gut bei geringer und mittlerer Kardinalität

– Jeder Schlüsselwert hat eine BITMAP mit einem Bit für jeden Datensatz

– z.B. Verpackungsart (Papier, Holz, Metall und Plastik) – 4 Bitmaps

– Komprimierte Speicherung – sehr effizient

– Mehrere BITMAPS können mit AND bzw. OR verknüpft werden.


INDEXE Fs.INDEXE Fs.B-Tree Index (eindeutig)CREATE UNIQUE INDEX emp_uk_namON employees (last_name, first_name, employee_id);

Index auf Funktion:CREATE INDEX upper_ix ON employees (UPPER(last_name));

Bitmap IndexCREATE BITMAP INDEX firstB ON employees (substr(last_name,1,1));


Views – DatensichtenViews – Datensichten

Logische Darstellung von Daten von einer oder mehreren Tabellen – base tables

Wie gespeicherte AbfrageAbfrage im Data Dictionary gespeichert

DESCRIBE Befehl– listet die Tabellen (View) Definition


Views – ErstellungViews – Erstellung

CREATE VIEW admin_employees ASSELECT first_name || last_name NAME, email, job_id POSITIONFROM employeesWHERE department_id = 10;

DESCRIBE admin_employeesCREATE FORCE VIEW ....

– Erstellt auch fehlerhafte Views


Views – Erstellung mit Views – Erstellung mit FeldnamenFeldnamenCREATE VIEW emp_hire(employee_id, employee_name, department_name, hire_date, commission_amt)AS SELECT employee_id, first_name || last_name,

department_name, to_char(hire_date, 'DD-MM-YYYY'), salary*NVL(commission_pct, 0.5)FROM employees JOIN departmentsUSING (department_id) ORDER BY first_name || last_name;


Views – Create mit Views – Create mit FehlernFehlern CREATE VIEW test_view as select c1, c2 from test_table

ORA-00942: table or view does not exist

CREATE FORCE VIEW test_view as select c1, c2 from test_table

SELECT * FROM test_view;ORA-04063: view "HR.TEST_VIEW" jas errors


Views – DiversesViews – Diverses

Read-Only Views:– WITH READ ONLY

Constraints können definiert werden

nur "deklarativ" – DISABLE NOVALIDATE

Ändern von Views – CREATE OR REPLACE– ALTER VIEWALTER VEIW test_view COMPILEnach Änderungen der Basistabelle

DROP VIEW


Views – VerwendungViews – Verwendung

Darstellung eines "Subsets" der Daten

Darstellung eines "Supersets" der Daten

Verdecken von komplexen JOINSVerwendung von sprechenden Feldnamen

Erreichung eines höheren Unabhängigkeitsgrades


Views – DatenänderungViews – Datenänderung

DML verwendbar mit Einschränkungen– kein DISTINCT– kein GROUP BY– kein ROWNUM– keine SET Operatoren (UNION ...)– kein Subquery in "SELECT" Klausel

Erzwingt nicht die "WHERE" Bedingung Joinviews

– nur 1 Tabelle veränderbar– nur die "key-preserved" Tabelle ist änderbar

Documents

1 Einführung in SQL Universeller Zugriff auf Daten in Datenbanksystemen unterschiedlicher Systemhersteller!