WEBVTT

00:02.170 --> 00:04.510
Wir kommen zur zwölften Übung.

00:07.130 --> 00:12.250
Es wurde ein weiteres Mal ein Studentenausweis gefunden.

00:13.650 --> 00:15.470
Wer seinen vermisst, möge...

00:15.470 --> 00:18.630
Ne, ich lese vielleicht einfach vor, was da für ein Name draufsteht.

00:18.710 --> 00:20.890
Alle, die nicht Andreas heißen, können schon mal aufatmen.

00:22.170 --> 00:25.250
Und die dann nicht Mähler heißen, können auch noch aufatmen.

00:26.450 --> 00:28.270
Haben wir denn jemanden hier, der so heißt?

00:29.190 --> 00:33.470
Wir können es auch gerne unter vier Augen ganz privat nachhören.

00:33.890 --> 00:35.510
Falls Sie sich jetzt schämen sollten.

00:40.040 --> 00:40.560
Okay.

00:42.240 --> 00:46.620
Also vorweg nochmal was Administratives zur Klausur, zur Anmeldung, um

00:46.620 --> 00:47.440
genauer zu sein.

00:47.820 --> 00:50.420
Es tut mir leid, dass sich das jetzt nun dummerweise schon wieder

00:50.420 --> 00:54.720
ändert, aber das wird jetzt auch so bleiben bis zum Ende tatsächlich.

00:56.400 --> 00:58.140
So, die Anmeldung für die Physiker.

00:58.140 --> 01:01.840
Nachdem wir jetzt ziemlich viel telefoniert haben mit den

01:01.840 --> 01:04.920
Prüfungskommissionen der Physiker und was weiß der Kuckuck, was da

01:04.920 --> 01:09.000
alles zuständig ist, und mit den Sekretärinnen diskutiert haben und

01:09.000 --> 01:09.760
alles hin und her.

01:10.260 --> 01:13.100
Für die Physiker ist das Ganze informell, diese Anmeldung.

01:13.240 --> 01:17.480
Das heißt, sie kommen einfach bei unserer Sekretärin vorbei, bei der

01:17.480 --> 01:22.160
Katja Weishaupt im AVG Gebäude 5041 im 2.

01:22.380 --> 01:22.620
OG.

01:23.200 --> 01:24.820
Der Raum ist hier ebenfalls angegeben.

01:24.820 --> 01:31.420
Sie tauchen auf mit Ihrem Studentenausweis, und zwar persönlich, und

01:31.420 --> 01:34.360
sagen dann einfach, dass Sie die Informatik 1 mitschreiben wollen.

01:34.660 --> 01:38.320
Frau Weishaupt wird Sie dann in die Liste eintragen.

01:38.500 --> 01:42.560
Sie brauchen also keinen Zettel, egal welche Farbe.

01:43.540 --> 01:48.620
Und bitte richten Sie sich so nach den hier angegebenen Sprechzeiten.

01:49.980 --> 01:55.540
Nämliches gilt für Schüler, da unsere Sekretärin letztes Jahr offenbar

01:55.540 --> 02:00.300
die Erfahrung gemacht hat, dass einige Zettel derart unleserlich

02:00.300 --> 02:04.200
waren, dass da nicht so ganz rauszufinden war, wer das nun eigentlich

02:04.200 --> 02:04.580
ist.

02:04.920 --> 02:08.940
Deswegen bitte die Schüler auch selber nochmal im Sekretariat

02:08.940 --> 02:12.840
vorbeigehen und sich anmelden oder gucken, wenn sie sich schon

02:12.840 --> 02:14.720
angemeldet haben, ob sie richtig in der Liste stehen.

02:15.260 --> 02:17.380
Adresse und Sprechzeiten wie oben.

02:17.940 --> 02:22.380
Als Hinweis an dieser Stelle noch die Hörsaalbelegung.

02:23.020 --> 02:24.700
Die wird natürlich vorher veröffentlicht.

02:25.060 --> 02:27.400
Das ist so eine große Liste, da sehen Sie Ihre Matrikelnummer und

02:27.400 --> 02:31.320
hintendran in welchem Hörsaal und ich glaube auch auf welchem Platz

02:31.320 --> 02:31.760
Sie sitzen.

02:33.200 --> 02:37.760
Und da würde ich Sie bitten, sich diese Liste rechtzeitig anzugucken.

02:38.480 --> 02:41.460
Denn wenn Sie auf dieser Liste fehlen, sind Sie nicht zur Klausur

02:41.460 --> 02:42.200
angemeldet.

02:42.600 --> 02:45.740
Und wenn Sie dann panisch auftauchen an dem 20.

02:46.000 --> 02:49.340
Februar und sagen, warum stehe ich nicht auf dieser Liste, wird es

02:49.340 --> 02:52.220
kompliziert, Sie dann noch zulassen zu wollen oder sonst was.

02:53.000 --> 02:55.880
Deswegen stellen Sie rechtzeitig sicher, dass Sie auf dieser Liste

02:55.880 --> 02:56.240
stehen.

02:57.800 --> 03:00.260
Und wenn nicht, dann kann man dann sicher Sie dann noch dazu

03:00.260 --> 03:00.640
schreiben.

03:00.760 --> 03:01.700
Das ist nicht das Problem.

03:02.160 --> 03:03.840
Aber wie gesagt, tun Sie es so bald wie möglich.

03:03.980 --> 03:08.240
Veröffentlicht wird die Liste auf info1.de und für die, die des

03:08.240 --> 03:11.180
Surfens nicht mächtig sind, hängen wir es natürlich auch in Papierform

03:11.180 --> 03:11.460
aus.

03:13.220 --> 03:13.820
So.

03:15.320 --> 03:20.160
Heute Morgen war ein sehr höflicher Student bei mir und hat mich

03:20.160 --> 03:22.460
gefragt, wie es denn aussähe mit Wiederabmelden.

03:23.340 --> 03:26.440
Ich habe ja die Hoffnung, dass keiner von Ihnen vorhat.

03:26.920 --> 03:30.040
Wenn es sich aber nicht vermeiden lassen sollte, wie sind denn die

03:30.040 --> 03:34.260
Modalitäten zum Abmelden, wenn Sie sich bereits für die Klausur

03:34.260 --> 03:35.180
angemeldet haben?

03:36.000 --> 03:39.800
Also, zuerst einmal gilt grundsätzlich, dass Sie sich bei einer

03:39.800 --> 03:43.980
schriftlichen Klausur da abmelden können, solange Sie die Klausur noch

03:43.980 --> 03:44.920
nicht in Händen haben.

03:45.360 --> 03:48.800
Sie können sich theoretisch abmelden, wenn Sie hier drin sitzen und

03:48.800 --> 03:51.760
wenn gefragt wird, muss jemand noch mal aufs Klo oder sowas, in der

03:51.760 --> 03:54.440
Richtung, dann können Sie immer noch sagen, hallo, hier, ich will

03:54.440 --> 03:55.120
nicht mitschreiben.

03:57.540 --> 03:59.560
Solange Sie die Klausur noch nicht in Händen halten.

04:01.380 --> 04:06.860
Jedoch wäre uns schon ganz recht, wenn Sie sich das, sagen wir mal,

04:06.860 --> 04:09.700
bis zu vier Tage vorher überlegen könnten.

04:10.320 --> 04:13.660
Weil dann können wir die Kapazitäten von den Hörsälen besser planen,

04:13.700 --> 04:16.700
dann können wir das mit den Sitzplätzen noch organisieren und sowas in

04:16.700 --> 04:17.120
der Richtung.

04:17.480 --> 04:19.400
Das ist also deutlich einfacher für uns.

04:21.400 --> 04:24.600
Wenn Sie bei der Klausur überhaupt nicht kommen und sich vorher nicht

04:24.600 --> 04:29.400
abgemeldet, aber vorher angemeldet haben, dann müssen Sie einen Attest

04:29.400 --> 04:30.860
vom Arzt anschleppen.

04:32.520 --> 04:36.280
Das gleiche gilt für mündliche Nachprüfungen, was ich ja nicht hoffe,

04:36.440 --> 04:37.200
dass es nötig ist.

04:38.220 --> 04:40.880
Aber was passieren kann, wenn Sie sich dort zu einem Prüfungstermin

04:41.340 --> 04:43.960
dann angemeldet haben und wenn Sie diesen Prüfungstermin nicht

04:43.960 --> 04:48.160
wahrnehmen können, dann können Sie sich ohne Attest nur bis drei

04:48.160 --> 04:51.820
Werktage vor dem Prüfungstermin nochmal abmelden.

04:51.960 --> 04:53.440
Danach brauchen Sie dann einen Attest.

04:55.380 --> 04:59.360
Für die Abmeldung gilt wieder das gleiche bei unserer Sekretärin Frau

04:59.360 --> 05:03.580
Katja Weishaupt von 10 bis 16 Uhr montags bis donnerstags im AVG.

05:06.060 --> 05:06.660
Okay.

05:07.940 --> 05:13.540
Da es doch ein bisschen Verwirrung offenbar gab, das haben wir in der

05:13.540 --> 05:17.920
letzten Tutorenrunde auch nochmal besprochen alles, möchte ich an

05:17.920 --> 05:21.600
dieser Stelle nochmal ganz eindeutig definieren, was wir unter einem

05:21.600 --> 05:22.820
Automaten verstehen.

05:25.240 --> 05:28.740
Es hat mich etwas gewundert, aber ich habe so eine formale Definition

05:28.740 --> 05:30.460
gar nicht gefunden auf den Webseiten.

05:30.460 --> 05:32.720
Damit ist sie hier nachgereicht.

05:33.320 --> 05:37.100
So ein Automat ist ein Fünftuppel und zwar haben wir eine Menge von

05:37.100 --> 05:37.920
Zuständen.

05:38.340 --> 05:39.920
Wichtig an dieser Menge ist es endlich.

05:41.200 --> 05:45.840
Wir haben einen Zustand aus den Zuständen, den wir als Startzustand

05:45.840 --> 05:52.560
bezeichnen und dann haben wir eine Menge möglicher akzeptierender

05:52.560 --> 05:56.680
Zustände, also das wäre so ein Wort, was wir dafür verbrauchen

05:56.680 --> 05:57.080
könnten.

05:58.200 --> 06:00.280
Die nennen wir auch Endzustände.

06:00.440 --> 06:03.680
Sie wissen, das sind die, die wir malen mit einem doppelten Kreis.

06:05.840 --> 06:08.360
Na klar, weil es eine Teilmenge einer endlichen Menge ist, ist die

06:08.360 --> 06:09.920
selber natürlich auch wieder endlich.

06:10.400 --> 06:14.340
Wir haben Sigma, das Eingabealphabet und wir haben eine

06:14.340 --> 06:15.420
Übergangsfunktion.

06:16.540 --> 06:19.760
Soweit war Ihnen das sehr wahrscheinlich schon allen klar.

06:20.600 --> 06:23.680
Was an dieser Stelle definiert sein soll, ist der vollständige,

06:23.740 --> 06:25.920
deterministische, endliche Automat.

06:26.960 --> 06:31.100
Einige von den Tutoren haben in vorauseilendem Gehorsam gleich noch

06:31.100 --> 06:36.500
den nicht-deterministischen, endlichen Automaten, auch mit Epsilon

06:36.500 --> 06:38.940
-Übergängen und weißer Kokobrust nicht noch alles.

06:39.440 --> 06:42.360
Aber dafür haben Sie ja noch ein ganzes Studium lang Zeit.

06:42.520 --> 06:44.480
Das muss alles nicht sein an dieser Stelle.

06:45.140 --> 06:48.600
Wir kennen nur den vollständigen, deterministischen, endlichen

06:48.600 --> 06:49.340
Automaten.

06:49.840 --> 06:53.100
Und wenn Sie einen Automaten bauen, dann bauen Sie nur einen

06:53.100 --> 06:56.280
vollständigen, deterministischen, endlichen Automaten.

06:57.200 --> 07:00.900
Was macht einen Automaten zu einem vollständigen, deterministischen

07:00.900 --> 07:02.140
und endlichen Automaten?

07:03.300 --> 07:08.100
Zum einen fordern wir, dass das eine echte Funktion ist, unsere

07:08.100 --> 07:09.280
Abbildung.

07:10.140 --> 07:13.560
Das macht dann nämlich den Automaten deterministisch, weil wir immer

07:13.560 --> 07:17.400
wissen, welches der nächste Zustand ist, wenn das nächste Zeichen

07:17.400 --> 07:17.820
kommt.

07:18.360 --> 07:21.280
Also hier hätten wir jetzt mal so ein Beispiel, irgendeinen Ausschnitt

07:21.280 --> 07:22.460
aus einem Automaten.

07:22.900 --> 07:25.860
Und wir befinden uns gerade in diesem Zustand hier und von außen kommt

07:25.860 --> 07:28.140
jetzt die Nachricht, okay, Eingabe war A.

07:28.980 --> 07:31.780
Sie sehen ein, wird ein bisschen schwierig zu entscheiden, wo wir dann

07:31.780 --> 07:32.520
als nächstes sind.

07:32.920 --> 07:36.100
Beim nicht-deterministischen Automaten sind wir halt in irgendeinem

07:36.100 --> 07:38.860
der beiden Zustände beziehungsweise man kann dann auch anfangen mit

07:38.860 --> 07:42.720
Potenzmengen von Zuständen zu rechnen, dass wir dann quasi in beiden

07:42.720 --> 07:43.620
oder auch keinem sind.

07:44.000 --> 07:45.440
Also an dieser Stelle gar nicht.

07:45.440 --> 07:47.260
Das ist verboten.

07:50.200 --> 07:55.120
Zweitens fordern wir eine totale Funktion und das macht eben den

07:55.120 --> 07:56.840
endlichen Automaten vollständig.

07:57.340 --> 08:01.940
Es gibt also keinen Zustand und irgendeine Eingabe, von der Sie sagen

08:01.940 --> 08:03.200
und was jetzt?

08:03.800 --> 08:07.660
Nehmen wir mal an, Sie haben einen Akzeptor gebaut, der das Wort ABC

08:07.660 --> 08:08.680
akzeptiert.

08:09.580 --> 08:13.040
Dann ist Ihr Eingabealphabet offensichtlich

08:16.420 --> 08:22.420
ABC und jetzt kann es natürlich sein, dass zuerst ein A kommt, okay,

08:22.900 --> 08:25.820
aber wenn als nächstes nicht ein B kommt, sondern nochmal ein A, was

08:25.820 --> 08:26.740
machen wir in dem Fall?

08:27.540 --> 08:31.980
Und dafür führen wir dann sogenannte Fehlerzustände ein.

08:33.220 --> 08:37.160
Das ist also ein Extrazustand, ein Endzustand, in dem wir dann auch

08:37.160 --> 08:43.180
bleiben und führen praktisch an alle bisher gehabten Knoten eine

08:43.180 --> 08:47.280
zusätzliche Kante ein, wo dann die, die wir eben dann als

08:47.280 --> 08:49.700
Fehlereingaben identifizieren, dran geschrieben sind.

08:50.340 --> 08:53.860
Klar ist, dass wir hier nie wieder rauskommen.

08:54.020 --> 08:57.020
Also sowas in der Richtung, wenn nochmal ein A kommt, ist es nochmal

08:57.020 --> 08:57.600
gerettet.

08:57.920 --> 08:59.580
Das gibt es natürlich nicht.

09:02.880 --> 09:04.900
Also wenn wir in dem Zustand sind, dann müssen wir da drin auch

09:04.900 --> 09:05.220
bleiben.

09:05.820 --> 09:10.040
So, dritte Anforderung oder dritte Eigenschaft ist, dass das Epsilon

09:10.040 --> 09:13.920
eben nicht in unserem Eingabealphabet ist.

09:14.600 --> 09:17.740
Also, dass wir nicht sagen können, naja, und jetzt ist er zwar in dem

09:17.740 --> 09:20.960
einen Zustand, wir gehen aber mal kurz in den anderen Zustand über, um

09:20.960 --> 09:22.340
dann von dort weiter zu machen.

09:22.980 --> 09:26.860
Also sowas in der Richtung, wir sind in einem Zustand und dann kommt

09:26.860 --> 09:30.860
ein A und dann gehen wir in den Zustand über, naja, und wären wir halt

09:30.860 --> 09:32.560
in dem gewesen, würden wir hier rüber gehen.

09:32.960 --> 09:35.880
Sie sehen ein, dass das natürlich das Gleiche ist, wie das, was wir da

09:35.880 --> 09:39.140
oben schon verboten haben und deswegen lassen wir Epsilon an dieser

09:39.140 --> 09:39.900
Stelle nicht zu.

09:41.280 --> 09:44.620
Wozu gibt es diese anderen komischen Automaten mit Epsilon-Übergängen

09:44.620 --> 09:46.500
oder die nicht-deterministischen oder sonst was?

09:46.820 --> 09:50.240
Die entstehen halt meistens bei irgendwelchen Algorithmen, wenn sie

09:50.240 --> 09:53.680
automatisch irgendwelche Akzeptoren zu irgendwelchen Sprachen oder

09:53.680 --> 09:58.000
sonst was erzeugen, dann treten schon mal hin und wieder solche Dinge

09:58.000 --> 10:02.020
auf und dann gibt es Algorithmen, die machen daraus vollständige

10:02.020 --> 10:04.000
deterministische und endliche Automaten.

10:04.000 --> 10:09.660
Wenn Sie von Handautomaten entwerfen, Moment, dann ist es für Sie

10:09.660 --> 10:13.480
natürlich kein Problem, den direkt so zu machen, wie er sein soll.

10:13.680 --> 10:14.420
Da war eine Frage.

10:24.980 --> 10:31.060
Gut, also die Frage war, warum soll der Fehlerzustand ein Endzustand

10:31.060 --> 10:31.440
sein?

10:33.800 --> 10:35.980
Damit würde das Wort ja auch akzeptiert.

10:37.840 --> 10:41.960
Sie könnten natürlich sagen, ich mache hier noch eine Schleife dran,

10:42.560 --> 10:46.360
mache keinen Endzustand und schreibe da A, B, C dran.

10:46.800 --> 10:47.740
Wäre auch eine Möglichkeit.

10:48.420 --> 10:50.820
Das ist halt einfach dann so, wie Sie den Automaten hinterher

10:50.820 --> 10:51.500
interpretieren.

10:52.900 --> 10:55.680
Also Sie könnten dann auch sagen, nee, ich mache keinen Endzustand.

10:56.780 --> 10:58.920
Aber ich denke, das ist an dieser Stelle jetzt nicht ganz so wichtig.

11:01.060 --> 11:07.660
So, auch zu den, ja, die Frage war schon wichtig, nur finde ich es

11:07.660 --> 11:11.900
nicht ganz so wichtig, ob jetzt Sie da einen Endzustand hinpinseln

11:11.900 --> 11:15.280
oder ob Sie dann da, also Sie müssten dann schon einen Fehlerzustand

11:15.280 --> 11:18.040
dran geschrieben haben, vielleicht, um das nochmal ganz zu

11:18.040 --> 11:18.600
beantworten.

11:19.740 --> 11:24.800
Gut, nochmal zu regulären Ausdrücken.

11:26.160 --> 11:32.360
Reguläre Ausdrücke kann man, oder reguläre Ausdrücke beschreiben ja

11:32.360 --> 11:33.660
eine akzeptierte Sprache.

11:34.320 --> 11:38.140
Dafür sind ja diese regulären Ausdrücke da, dass wir eine akzeptierte

11:38.140 --> 11:41.300
Sprache sehr leicht darstellen können.

11:42.140 --> 11:45.360
Und deswegen kann ich zu jedem regulären Ausdruck, den ich angeben

11:45.360 --> 11:50.360
kann, auch eine Sprache angeben, so wie wir das damals im Kapitel 2

11:50.360 --> 11:51.520
schon gemacht haben.

11:51.520 --> 11:55.180
Also die Sprache von, wenn ich die leere, als regulären Ausdruck die

11:55.180 --> 12:00.000
leere Menge habe, ist dann einfach eine Sprache ganz ohne Worte.

12:00.680 --> 12:03.840
Wenn ich als regulären Ausdruck Epsilon zulasse, Sie erinnern sich,

12:04.260 --> 12:08.460
das wollen wir ja unterscheiden, dann ist die Sprache davon die Menge,

12:08.620 --> 12:10.640
in der eben nur das leere Wort drin ist.

12:11.800 --> 12:15.580
Und wenn ich irgendeine Konstante habe oder irgendein C, also ein

12:15.580 --> 12:20.200
Zeichen aus meinem Alphabet, dann ist die Sprache gerade das Wort, was

12:20.200 --> 12:21.840
nur aus diesem einen Zeichen besteht.

12:23.060 --> 12:28.740
Wenn wir nun zwei reguläre Ausdrücke R und S haben, dann stehen die so

12:28.740 --> 12:34.100
im Zusammenhang, dass R plus S das gleiche ist wie die Sprache der

12:34.100 --> 12:37.240
Vereinigung, also die Vereinigung der beiden Mengen.

12:38.060 --> 12:42.940
Dann RS ist dann die Verknüpfung der beiden Mengen, und zwar der Form,

12:43.040 --> 12:46.900
dass ich erst ein W1 aus R nehme und dann ein W2 aus S, die beiden

12:46.900 --> 12:47.860
hintereinander schreibe.

12:47.940 --> 12:50.920
Das ist dann die Sprache, die von RS beschrieben wird.

12:51.540 --> 12:57.000
Und für den regulären Ausdruck R-Stern ist dann die Sprache einfach

12:57.000 --> 13:01.520
die, wir nehmen irgendwelche Wi aus unserem R raus, zwischen Null und

13:01.520 --> 13:04.380
beliebig vielen, und schreiben die alle hintereinander, und das ist

13:04.380 --> 13:05.840
dann unser R-Stern.

13:08.240 --> 13:12.440
Wie könnte jetzt hierzu eine Aufgabe aussehen auf dem Übungsblatt oder

13:12.440 --> 13:13.740
in der Klausur?

13:14.720 --> 13:18.380
Die könnte so aussehen, seien S und T, die Sprachen zu S

13:18.380 --> 13:22.340
beziehungsweise T, und dann ist die Frage, die wir uns stellen, für

13:22.340 --> 13:28.260
welche Sprachen S und T gilt, dass die Sprache von S plus T Stern

13:29.040 --> 13:33.700
gleich der Sprache ST, also die Konkatenation Stern, ist?

13:34.520 --> 13:38.660
Das sind offensichtlich nicht alle, aber vielleicht doch die ein oder

13:38.660 --> 13:39.000
andere.

13:41.300 --> 13:46.380
Sie sehen ein, dass ich das nicht einfach sagen kann, na das ist das

13:46.380 --> 13:54.420
Gleiche, genau dann, wenn S plus T gleich ST, den Stern einfach

13:54.420 --> 13:55.160
wegzulassen.

13:56.140 --> 14:05.560
Weil, nehmen wir mal an, S wäre A und T wäre Epsilon,

14:10.100 --> 14:11.880
beziehungsweise klein S und klein T.

14:13.100 --> 14:26.540
Dann wäre jetzt L von S plus T gleich oh Entschuldigung, da fehlt noch

14:26.540 --> 14:36.000
ein Stern, das Epsilon, das A, das AA, das AAA und so weiter.

14:37.120 --> 14:53.520
Und L von ST Stern wäre dann das Gleiche wie AA, AAA und so weiter.

14:55.000 --> 14:55.600
Warum?

14:56.160 --> 14:59.600
Wir fordern, dass ein S und ein T vorkommen.

15:00.100 --> 15:03.800
Das S ist das A, also diese Darstellung ist natürlich nicht richtig.

15:08.500 --> 15:13.220
Es muss ja auf jeden Fall ein S und ein T kommen und deswegen haben

15:13.220 --> 15:15.360
wir hier mindestens einen Buchstaben in dem Fall.

15:21.770 --> 15:25.910
Stern bedeutet 0 mal, deswegen

15:30.320 --> 15:45.000
ist L von S und T wäre die Menge, Epsilon und hier wäre L von S und T

15:45.000 --> 15:47.260
wäre A.

15:49.480 --> 15:51.960
Also, Sie haben recht, hier kommt auch noch das Epsilon rein.

15:53.720 --> 15:55.880
Das ist nämlich genau das Gegenbeispiel, was ich Ihnen zeigen sollte,

15:55.960 --> 15:57.020
sonst hätte es ja gar nicht funktioniert.

15:57.740 --> 16:03.400
Also, jetzt fällt es mir auch wieder siebenwarm ein, dass das ja

16:03.400 --> 16:04.280
eigentlich dahin sollte.

16:04.720 --> 16:09.380
Gut, also Sie sehen ein, wenn das nicht das Gleiche ist, kann das hier

16:09.380 --> 16:10.780
nämlich trotzdem das Gleiche sein.

16:11.280 --> 16:14.060
Also reicht es nicht einfach zu sagen, wir lassen den Stern weg und

16:14.060 --> 16:16.580
wenn dann gleich, dann haben wir gezeigt das.

16:17.180 --> 16:20.240
Drum schauen wir uns mal an, wie wir das vielleicht dann formal

16:20.240 --> 16:21.200
korrekt hinkriegen.

16:22.120 --> 16:24.800
Es ist jetzt natürlich ein bisschen blöd, dass das dasteht, aber es

16:24.800 --> 16:27.520
ist auch wieder gut, weil dann können Sie es lesen.

16:29.040 --> 16:32.740
S und T, diese beiden Sprachen, sind Mengen von Wörtern.

16:33.780 --> 16:36.720
Und da es Mengen sind, dürfen wir, wenn wir jetzt irgendwelche Beweise

16:36.720 --> 16:39.580
führen wollen, natürlich die Gesetze der Mengenalgebra anwenden.

16:41.480 --> 16:43.400
Und das sähe dann in dem Beispiel so aus.

16:45.120 --> 16:50.200
Wir wollen ja zuerst mal prüfen, in dem Fall für Gleichheit, wann ist

16:50.200 --> 16:52.740
denn die rechte Seite in der linken Seite enthalten.

16:55.000 --> 17:00.140
Offensichtlich gilt, dass L von S, T eine Teilmenge ist von L plus T

17:00.140 --> 17:00.540
-Stern.

17:01.740 --> 17:05.600
Weil, wenn ich die hintereinander schreibe, also die Kombination

17:05.600 --> 17:07.220
kriege ich hier auf jeden Fall auch hin.

17:07.480 --> 17:10.420
Ich habe ja Stern, also habe ich sie da alle drin, also kriege ich das

17:10.420 --> 17:11.320
auf jeden Fall mal hin.

17:12.260 --> 17:17.440
So, daraus folgt, wenn ich davon null bis beliebig viele

17:18.280 --> 17:21.500
hintereinander schreiben kann, dann ist das das Gleiche, wie wenn ich

17:21.500 --> 17:24.300
hier natürlich auch null von beliebig viele dahinter schreiben kann.

17:24.380 --> 17:26.260
Deswegen gilt auch diese Inklusion.

17:27.800 --> 17:33.420
Dieser doppelte Stern bringt uns aber keine Zusatzinformationen.

17:33.420 --> 17:36.360
Wenn ich etwas null bis beliebig oft nehmen kann und dieses Ergebnis

17:36.360 --> 17:39.220
null bis beliebig oft, dann ist es das Gleiche, wie wenn ich gleich

17:39.220 --> 17:42.280
das hier null bis beliebig oft nehmen kann.

17:47.070 --> 17:47.550
Name?

17:51.980 --> 17:52.460
Gut.

17:52.460 --> 17:52.940
Tschüss.

18:00.310 --> 18:01.730
So, jetzt wissen Sie auch, wie der heißt.

18:04.990 --> 18:05.390
Gut.

18:06.870 --> 18:12.170
Sie sehen, wir brauchen überhaupt keine Anforderungen an S und T zu

18:12.170 --> 18:18.330
stellen, damit diese Inklusion gilt, damit also ST-Stern in S plus T

18:18.330 --> 18:19.630
-Stern enthalten ist.

18:20.650 --> 18:21.930
Wie ist es mit der Rückrichtung?

18:23.050 --> 18:26.390
Also, dass S plus T-Stern enthalten ist in ST-Stern.

18:27.610 --> 18:32.710
Nehmen wir mal an, es gelte L von S ist eine Teilmenge von L von ST

18:32.710 --> 18:36.870
-Stern und L von T ist eine Teilmenge von L von ST-Stern.

18:38.290 --> 18:41.990
Hält jetzt ein bisschen vom Himmel, aber beim Beweisen versuchen, habe

18:41.990 --> 18:44.150
ich halt irgendwie herausgefunden, dass das wohl so zu stimmen

18:44.150 --> 18:44.470
scheint.

18:44.590 --> 18:48.510
Und deswegen ist es so, dass ich Ihnen jetzt mal sage, wenn man das

18:48.510 --> 18:49.310
nimmt, dann klappt es.

18:51.590 --> 18:54.570
Also, als erstes müssen wir zeigen, dass das eine hinreichende

18:54.570 --> 18:55.170
Bedingung ist.

18:55.550 --> 18:59.650
Dass wenn das hier gilt, dass dann diese Inklusion gilt.

19:00.190 --> 19:05.570
Geht dann folgendermaßen, daraus, dass L von S Teilmenge von L von ST

19:05.570 --> 19:10.310
und L von T Teilmenge von L von ST ist, ist natürlich, wenn ich das

19:10.310 --> 19:15.990
eine oder das andere nehme, das enthalten in wenn ich das hier nehme

19:15.990 --> 19:17.470
oder wenn ich das hier nehme.

19:18.630 --> 19:20.270
Logischerweise, das sind die beiden da oben.

19:21.310 --> 19:25.370
Das ist also praktisch genau das und das und das und das, einfach

19:25.370 --> 19:26.270
verodert.

19:27.250 --> 19:30.410
Den nächsten Schritt hätten Sie auch direkt selber raten können.

19:30.890 --> 19:32.690
Das ist natürlich genau das gleiche wie das.

19:35.290 --> 19:42.130
Und in dem Fall stellen wir dann eben fest, dass S plus T Stern eine

19:42.130 --> 19:45.710
Teilmenge ist von S T Stern Stern.

19:46.350 --> 19:49.910
Und wie oben gilt jetzt natürlich wieder genauso, dass man dieses

19:49.910 --> 19:52.310
Stern Stern auch zu einem Stern zusammenziehen kann.

19:52.310 --> 19:56.970
Und damit haben wir gezeigt, dass das hier eine Teilmenge von dem da

19:56.970 --> 19:57.250
ist.

19:59.530 --> 20:01.830
Wir haben also gezeigt, dass das Ding hinreichend ist.

20:02.150 --> 20:07.230
Und jetzt fragt sich natürlich, gäbe es auch noch eine kleinere oder

20:07.230 --> 20:09.290
eine leichtere Bedingung, die das Ganze erfüllt.

20:09.830 --> 20:12.610
Das testen wir einfach, indem wir versuchen, die Notwendigkeit zu

20:12.610 --> 20:13.090
beweisen.

20:14.050 --> 20:25.470
Das heißt, OBDA sei L von S eben nicht S T Stern Ja Ja

20:34.930 --> 20:45.740
Ja Beispiel hier oben.

20:45.960 --> 20:50.180
Wenn T also gerade mal Epsilon erzeugt, dann können Sie das Wort S

20:50.180 --> 20:51.440
erzeugen.

20:53.760 --> 20:55.780
Wir fordern, dass das so ist.

20:57.460 --> 20:59.840
Diese Anforderung stellen wir an S und T.

21:01.860 --> 21:05.200
Ja und jetzt wollen wir beweisen, dass wenn wir diese Anforderungen an

21:05.200 --> 21:09.440
S und T stellen, dass das hinreichend ist, aber auch notwendig.

21:10.700 --> 21:12.160
Hinreichend habe ich Ihnen gerade gezeigt.

21:13.060 --> 21:15.580
Jetzt zeige ich Ihnen, dass es auch noch notwendig ist, dass es also

21:15.580 --> 21:16.240
kleiner nicht geht.

21:16.320 --> 21:18.160
Jetzt habe ich vergessen, was ich Ihnen nochmal zeigen wollte.

21:18.720 --> 21:21.660
Also wir nehmen ja an, dass hier gilt.

21:22.300 --> 21:25.620
Und jetzt zeigen wir, dass es notwendig ist, indem wir annehmen, dass

21:25.620 --> 21:27.000
eins von den beiden nicht gilt.

21:27.300 --> 21:30.420
Sie sehen ein, dass ich da jetzt einfach das dann annehmen kann, dass

21:30.420 --> 21:30.900
es nicht gilt.

21:31.000 --> 21:32.700
Das ist ja symmetrisch zu diesem Fall hier.

21:34.100 --> 21:37.860
Also DBA sei S eben nicht Teilmenge von S T Stern.

21:39.480 --> 21:45.060
Es gilt, wie eben auch, L von S ist Teilmenge von S oder T.

21:47.720 --> 21:53.800
Und es gilt, L von S oder T ist natürlich eine Teilmenge von S oder T

21:53.800 --> 21:54.440
Stern.

21:56.180 --> 22:03.120
Und daraus folgern wir dann in dem Fall, dass L von S oder T keine

22:03.120 --> 22:05.840
Teilmenge von L von S und T ist.

22:07.180 --> 22:12.460
Also wir haben ja gesagt, hier oben, dass L von S, was eine Teilmenge

22:12.460 --> 22:15.520
von diesem Ausdruck ist, ist nicht hier drin enthalten.

22:17.020 --> 22:22.860
Wenn eine Teilmenge von diesem Ausdruck schon nicht enthalten ist, in

22:22.860 --> 22:25.640
dem Ausdruck, dann kann der ganze Ausdruck hier auch nicht mehr drin

22:25.640 --> 22:26.320
enthalten sein.

22:27.100 --> 22:27.840
Das sehen Sie ein.

22:28.880 --> 22:33.760
Und damit widerspricht es also unserer Voraussetzung, dass wir diese

22:33.760 --> 22:35.340
Inklusion eben annehmen wollen.

22:36.500 --> 22:40.200
Und damit können wir sagen, die Anforderungen an S und T sind, dass S

22:40.200 --> 22:45.140
jetzt eine Teilmenge ist von L von S T Stern und T eine Teilmenge von

22:45.140 --> 22:46.160
S T Stern.

22:46.160 --> 22:51.640
Und das Beispiel vorher hat Ihnen genau ein Paar gezeigt, was das eben

22:51.640 --> 22:52.060
erfüllt.

22:55.130 --> 22:56.650
Kommen wir zum nächsten Thema.

22:57.390 --> 22:58.530
Module in Haskell.

22:58.610 --> 23:01.290
Wir haben sie schon mal angesprochen, wir haben sie auch schon mal

23:01.290 --> 23:03.230
ganz kleines bisschen benutzt.

23:03.870 --> 23:06.910
Wir wollen das an dieser Stelle aber jetzt ein bisschen vertiefen.

23:09.770 --> 23:16.290
Wir haben in Haskell die Programmzeilen, die Anzahl ist natürlich

23:16.290 --> 23:18.390
deutlich geringer als in imperativen Sprachen.

23:18.770 --> 23:21.010
Nichtsdestotrotz kann es aber auch sein, dass auch in Haskell ein

23:21.010 --> 23:22.850
Programm rauskommt, was ein bisschen länger wird.

23:23.550 --> 23:26.710
Der Übersichtlichkeit halber fangen wir dann an, als Informatiker,

23:26.870 --> 23:29.890
alles zu zerhacken und in Komponenten aufzuteilen.

23:30.330 --> 23:33.230
Und in Haskell heißen diese Komponenten eben Module.

23:34.350 --> 23:38.390
Und jedes dieser Module in Haskell definiert eine Menge von Werten,

23:38.450 --> 23:41.310
Datentypen, Klassen und so weiter, was Sie alles kennen.

23:43.530 --> 23:49.170
Und ein Modul kann jetzt anfangen, diese Entitäten, wie man diese

23:49.170 --> 23:53.150
Dinger auch nennt, zu exportieren.

23:53.650 --> 23:57.410
Und zwar kann es derer 0 exportieren, 1 exportieren, 2, 3 und so

23:57.410 --> 24:00.150
weiter bis zu alle seine Entitäten.

24:01.590 --> 24:07.870
Das ist übrigens auch mit dem Entitätenbegriff, das ist eigentlich

24:07.870 --> 24:15.190
immer gleich, das ist, wenn Sie so ein Artefakt haben und immer als

24:15.190 --> 24:17.690
Ganzes irgendwo neu hineinsetzen.

24:18.230 --> 24:23.530
Also bei XML kennen Sie ja die Entitäten mit den also als Entities mit

24:23.530 --> 24:25.970
dem und, a, uml zum Beispiel

24:30.180 --> 24:31.140
für ein ä.

24:31.580 --> 24:34.160
Da ist dann halt einfach die Entität das ä.

24:34.380 --> 24:40.640
Das ist für Sie dann, wenn Sie es verwenden, ist es atomar und Sie

24:40.640 --> 24:44.840
können es also nicht weiter zerhacken, Sie können es einfach als

24:44.840 --> 24:47.020
komplettes nehmen, reinsetzen und benutzen.

24:47.760 --> 24:50.800
Und so ist es mit den Entitäten in Haskell dann genauso.

24:50.920 --> 24:54.260
Was Sie hier halt exportiert bekommen in Haskell, das können Sie

24:54.260 --> 24:58.240
nehmen, reinsetzen und benutzen und Sie können es nicht mehr

24:58.240 --> 24:59.000
auseinandernehmen.

24:59.840 --> 25:04.240
So, wenn man sie exportieren kann, die Entitäten, dann kann man sie

25:04.240 --> 25:07.640
natürlich in anderen Modulen auch wieder importieren, spricht man an

25:07.640 --> 25:08.940
dieser Stelle davon.

25:10.120 --> 25:14.680
Und was weiter gilt, ist, dass Module importierte Entitäten auch

25:14.680 --> 25:15.920
wieder exportieren können.

25:16.440 --> 25:20.040
Wichtig ist, dass es wirklich nur ein Können ist und eben kein Müssen,

25:20.480 --> 25:22.500
aber das schauen wir uns gleich noch genauer an.

25:24.720 --> 25:29.200
Hier für diese Vorlesung gelt mal, dass jedes Modul in einer eigenen

25:29.200 --> 25:33.340
Datei landet, die genauso heißt wie das Modul, verknüpft mit der

25:33.340 --> 25:36.720
Endung hs und die liegt am besten im gleichen Verzeichnis.

25:37.680 --> 25:41.340
Sie können je nach Interpreter auch mehrere Module in eine Datei tun

25:42.420 --> 25:46.580
oder ihre Module sonst wo zerstreuen, jedoch wird z.B.

25:47.920 --> 25:52.200
irgendein Modul x eben auch in einer Datei x.hs suchen.

25:52.680 --> 25:54.940
Und die muss dann irgendwo in Ihrem Suchpfad drin sein, d.h.

25:55.040 --> 25:58.080
Sie können sie irgendwo in dem Library-Verzeichnis drin haben oder

25:58.080 --> 25:59.580
einfach im aktuellen Verzeichnis.

25:59.580 --> 26:00.140
D.h.

26:00.240 --> 26:03.540
wenn Sie diese Konvention benutzen, wissen Sie selber, wo Sie Ihr

26:03.540 --> 26:04.460
Modul zu finden haben.

26:04.820 --> 26:06.620
Haskell weiß, wo es das Modul zu finden hat.

26:08.520 --> 26:09.940
Und alle sind glücklich.

26:11.880 --> 26:14.140
Gut, wie benutzen wir Module?

26:14.320 --> 26:16.400
Diese Folie haben wir schon mal gesehen, d.h.

26:16.480 --> 26:20.400
wir können entweder ein Modul komplett importieren, mit Import in

26:20.400 --> 26:20.940
diesem Fall.

26:21.360 --> 26:25.140
Wir können auch nur Teile eines Moduls importieren, z.B.

26:25.300 --> 26:29.340
aus dem Modul File in dem Fall Datei, PUT und EOF.

26:29.800 --> 26:34.660
Oder wir machen ein sogenanntes qualifiziertes Importieren, wobei dann

26:34.660 --> 26:38.220
die importierten Dinge nur sichtbar sind, wenn man sie vorher mit

26:38.220 --> 26:42.380
diesem Modulname Punkt qualifiziert.

26:43.060 --> 26:47.300
Das Ganze wollen wir uns mal ein bisschen genauer anschauen, wie das

26:47.300 --> 26:48.520
im Einzelnen funktioniert.

26:49.480 --> 26:52.020
Und dafür wollen wir uns einfach mal die Fälle anschauen, die es da

26:52.020 --> 26:52.240
gibt.

26:52.380 --> 26:55.900
Und nehmen wir an, es gäbe ein Modul A und da drin wären zwei

26:55.900 --> 26:57.500
Entitäten X und Y.

26:58.200 --> 26:59.340
Die werden exportiert.

27:00.440 --> 27:05.640
So, der erste Fall einfach nur eine Importanweisung mit einer Liste

27:05.640 --> 27:06.280
hintendran.

27:06.680 --> 27:09.440
Schauen wir uns an, was jeweils sichtbar ist.

27:09.820 --> 27:10.060
D.h.

27:10.180 --> 27:14.360
wenn Sie einfach A importieren, Ihr Modul, dann sehen Sie die Entität

27:14.360 --> 27:19.360
X, die Entität Y und natürlich auch qualifiziert über A.X und A.Y.

27:20.220 --> 27:24.700
Wenn Sie eine leere Importliste verwenden, dann sehen Sie natürlich

27:24.700 --> 27:25.120
nichts.

27:25.900 --> 27:30.660
Und wenn Sie irgendwelche Entitätennamen hier reinschreiben in die

27:30.660 --> 27:34.080
Importliste, dann importieren Sie genau die Entitäten, die Sie da

27:34.080 --> 27:34.740
benannt haben.

27:35.120 --> 27:38.320
Und die sind dann vorhanden, zusammen mit Ihrer qualifizierten

27:38.320 --> 27:39.220
Bezeichnung.

27:42.120 --> 27:42.680
Nächste...

27:42.680 --> 27:45.380
und den Parameter, den wir noch dazu angeben können, ist dann eben

27:45.380 --> 27:46.100
Qualified.

27:46.100 --> 27:50.020
Und dann existieren, wenn wir das Modul A importieren, eben nur die

27:50.020 --> 27:54.100
qualifizierten Namen innerhalb des aktuellen Moduls.

27:55.640 --> 27:58.800
Und mit der Liste, das funktioniert genauso wie oben, dann ist

27:58.800 --> 27:59.980
natürlich wieder nichts mehr da.

28:00.500 --> 28:04.340
Und in dem Fall sehe ich dann eben auch noch, wenn ich jetzt nur das X

28:04.340 --> 28:08.680
importiere, auch nur das A.X und eben nur das A.X und nicht das X,

28:08.760 --> 28:10.660
weil ich Import Qualified gemacht habe.

28:12.000 --> 28:15.520
Dann an dieser Stelle noch so zwischen den Zeilen ein neues

28:15.520 --> 28:18.540
Schlüsselwort eingeführt, nämlich dieses Hiding.

28:18.980 --> 28:24.040
Sie können auch irgendein Modul importieren und davon irgendwelche

28:24.040 --> 28:26.560
Entitäten verstecken, weil Sie die gar nicht brauchen, weil Sie die

28:26.560 --> 28:30.260
nicht sehen wollen oder weil die so heißen wie etwas, was Sie brauchen

28:30.260 --> 28:32.880
von sich selber und halt dummerweise genauso heißt.

28:33.340 --> 28:36.380
Mit leerer Liste verstecken Sie nichts, nehmen wieder das gleiche auf,

28:36.620 --> 28:38.160
wie was Sie da oben gehabt haben.

28:38.540 --> 28:42.540
Und wenn Sie jetzt das X verstecken, bleibt Ihnen eben nur Y und A.Y.

28:43.340 --> 28:47.560
Das Ganze ist orthogonal, das heißt, Sie können das eine zusammen mit

28:47.560 --> 28:51.060
dem anderen verwenden und das macht immer noch das gleiche wie vorher

28:51.060 --> 28:51.360
auch.

28:51.780 --> 28:56.360
Also Qualified Hiding bleibt Ihnen wegen dem Qualified eben das Ganze

28:56.360 --> 29:01.380
ohne Qualifizierung weg.

29:01.640 --> 29:04.780
Sehen Sie dann nicht mehr und mit dem Hiding dann eben bleibt das A.X

29:04.780 --> 29:05.380
auch noch weg.

29:07.020 --> 29:11.340
Als letzten Punkt, den ich hier ansprechen möchte, ist, dass Sie ein

29:11.340 --> 29:13.100
Modul auch noch umbenennen können.

29:13.620 --> 29:17.300
Das heißt, Sie können A in B umbenennen bei importieren.

29:17.880 --> 29:21.420
Für X und Y für den Zugriff ändert sich natürlich nichts, aber wenn

29:21.420 --> 29:23.980
Sie den qualifizierten Zugriff treiben wollen, dann können Sie nicht

29:23.980 --> 29:26.620
mehr A Punkt irgendwas schreiben, sondern müssen in dem Fall dann eben

29:26.620 --> 29:27.520
B Punkt schreiben.

29:28.300 --> 29:32.160
Und die letzten beiden Fälle sind eben auch wieder genauso, wie wir

29:32.160 --> 29:33.380
uns das erwarten.

29:35.700 --> 29:40.540
So, ich habe gesagt, Module können importierte Entitäten wieder

29:40.540 --> 29:42.080
exportieren, müssen es aber nicht.

29:42.740 --> 29:44.920
Hier wollen wir uns das mal an einem Beispiel anschauen.

29:45.740 --> 29:51.180
Wir haben mal ein Modul End und in diesem Modul End haben wir jetzt

29:51.180 --> 29:53.160
irgendeinen Datentyp definiert und eine Funktion.

29:53.680 --> 29:55.980
Also einmal Ends und einmal End Eta.

30:01.920 --> 30:06.600
Jetzt machen wir uns ein Modul B und importieren oben unser oben

30:06.600 --> 30:12.200
definiertes Modul und importieren, wie Sie sehen, tatsächlich alles.

30:12.740 --> 30:16.300
Also einmal unseren Datentyp und einmal unsere Funktion und definieren

30:16.300 --> 30:19.280
zusätzlich noch einen B-Keeper, eine Konstante.

30:21.320 --> 30:24.040
Damit wir was Importiertes auch wieder exportieren können, brauchen

30:24.040 --> 30:28.040
wir jetzt natürlich ein drittes Modul, in dem Fall K, und da

30:28.040 --> 30:29.320
importieren wir wieder B.

30:30.980 --> 30:35.700
Und jetzt ist es so, dass in dem Modul K zwar dieses B-Keeper sichtbar

30:35.700 --> 30:41.280
ist, aber eben nicht der Datentyp und die oben definierte Funktion.

30:41.660 --> 30:46.120
Die sind im K dann eben nicht sichtbar, als Hinweis.

30:50.600 --> 30:53.580
Wie kontrollieren wir denn, was jetzt exportiert wird?

30:54.040 --> 30:57.920
Also Sie wissen ja noch, wie man ein Modul definiert, bzw.

30:58.280 --> 31:01.360
Sie wissen es theoretisch, wenn Sie es auch praktisch möglicherweise

31:01.360 --> 31:02.320
noch nicht gemacht haben.

31:04.000 --> 31:08.140
Wir schreiben Modul-Modul-Name, Where und dann irgendwelche

31:08.140 --> 31:11.880
Definitionen hintendran, also unser Datentypen und so weiter.

31:12.600 --> 31:15.560
Und wenn wir hier noch eine Klammer angeben und da drin irgendwelche

31:15.560 --> 31:19.660
Namen aufschreiben, dann ist es das, was wir mit diesem Modul jetzt

31:19.660 --> 31:20.360
exportieren.

31:21.140 --> 31:22.540
Wozu haben wir diese Kontrolle?

31:23.260 --> 31:26.440
Wir haben uns vielleicht irgendwelche Funktionen definiert, die dann

31:26.440 --> 31:30.840
da heißen Hilf und weil sich jeder seine Funktion Hilf immer so

31:30.840 --> 31:33.400
definiert, dass sie Hilf heißt, ist es natürlich ein bisschen blöd.

31:33.580 --> 31:37.960
Dann kann nachher muss jeder sie Hilf 1, Hilf 2 und so weiter nennen.

31:38.540 --> 31:41.520
Deswegen wollen wir unsere Hilfsfunktionen ja gar nicht exportieren.

31:41.620 --> 31:45.340
Wir wollen ja nur das, was wir tatsächlich unserem Kunden, also dem

31:45.340 --> 31:48.660
Benutzer unseres Moduls an Mehrwert bieten, auch bieten.

31:48.820 --> 31:50.020
Den Rest, der interessiert ihn nicht.

31:50.120 --> 31:52.080
Deswegen beschützen wir ihn auch davor.

31:52.080 --> 31:57.020
Also wir sagen hier in dem Modul B, dass wir natürlich unsere Funktion

31:57.020 --> 31:58.020
exportieren wollen.

31:58.760 --> 32:02.720
Dann wollen wir unseren Datentyp exportieren und die Funktionen.

32:03.020 --> 32:06.960
Jetzt sehen Sie hier diese zwei Punkte mit den Klammern drumherum.

32:07.800 --> 32:11.000
Und das bedeutet eben, dass wenn Sie das verwenden mit diesen

32:11.000 --> 32:15.200
Klammern, dann werden auch alle Konstruktoren des Typs mit exportiert.

32:15.460 --> 32:18.080
Und wenn Sie das nicht verwenden, dann wird er eben als Abstraktor

32:18.080 --> 32:20.600
-Datentyp exportiert, ohne die Konstruktoren.

32:22.100 --> 32:22.320
So.

32:27.460 --> 32:34.100
Wenn Sie hier an dieser Stelle statt den einzelnen Aufzählungen das

32:34.100 --> 32:39.340
hier verwenden, also Modul Ernt hinschreiben, dann exportieren Sie

32:39.340 --> 32:42.380
tatsächlich alles, was Sie von Ernt bekommen haben.

32:45.980 --> 32:49.460
Das funktioniert also so, wenn Sie Modul Modul Name da oben

32:49.460 --> 32:52.920
reinschreiben, dann ist das im Endeffekt nur eine Abkürzung, als wenn

32:52.920 --> 32:57.700
Sie einfach alles da oben reingeschrieben hätten, was dort exportiert

32:57.700 --> 32:57.960
wird.

32:58.340 --> 33:03.860
So sieht dann zum Beispiel eine Signatur Modul Fishware irgendwas, ist

33:04.840 --> 33:10.340
semantisch genau das gleiche wie Modul Fish exportiert Modul Fishware

33:10.340 --> 33:11.160
irgendwas.

33:12.280 --> 33:15.640
Kann sich irgendjemand von Ihnen vorstellen, warum importiert es nicht

33:15.640 --> 33:17.420
automatisch weiter exportiert wird?

33:20.900 --> 33:21.760
So eine Idee.

33:23.860 --> 33:24.420
Ja, bitte.

33:29.740 --> 33:32.580
Ja, er sagt, könnte was zweimal importiert werden, über zwei

33:32.580 --> 33:33.540
verschiedene Wege.

33:33.960 --> 33:40.060
Das ist natürlich, wenn ich irgendwo die Prelude verwende, die ich ja

33:40.060 --> 33:43.940
in aller Regel schon brauche, dann kämen sie auch zweimal rein und ich

33:43.940 --> 33:46.380
sehe das Ganze und muss dann wieder meins raus sortieren, was ich

33:46.380 --> 33:48.760
gerne sehen möchte bei der Dokumentation oder sonst irgendwas.

33:48.760 --> 33:53.180
Deswegen ist es vielleicht eine ganz gute Entscheidung so, ist aber

33:53.180 --> 33:55.420
letztendlich doch eine willkürliche Entscheidung.

33:58.160 --> 34:01.180
Die Verwendung von Modulen wollen wir uns mal an der Fallstudie

34:01.180 --> 34:01.600
angucken.

34:02.180 --> 34:05.840
Wir haben die Huffman Codes durchgenommen und wollen die jetzt mal in

34:05.840 --> 34:08.320
Haskell implementieren.

34:08.320 --> 34:12.360
Zur Erinnerung, Huffman Codes, wir hatten irgendeinen Zeichenvorrat

34:12.360 --> 34:18.580
Sigma mit n Zeichen drin und zugehörig die Wahrscheinlichkeit P von ZI

34:18.580 --> 34:23.260
gleich PI und dabei gilt dann natürlich, dass die Summe über alle P

34:23.260 --> 34:25.000
gleich 1 ist.

34:25.800 --> 34:28.900
Logischerweise, weil das ja alle unsere Zeichen sind.

34:31.180 --> 34:35.320
Der erste Schritt war für die Huffman Codierung, wir ordnen die

34:35.320 --> 34:42.940
Zeichen nach fallender Wahrscheinlichkeit an und danach fassen wir die

34:42.940 --> 34:46.340
Zeichen mit der niedrigsten Wahrscheinlichkeit, also die da hinten

34:46.340 --> 34:50.320
irgendwie, zusammen zu einem neuen Zeichen, berechnen die

34:50.320 --> 34:54.160
Wahrscheinlichkeit des neuen Zeichens und sortieren es dann wieder

34:54.160 --> 34:56.260
hier irgendwo in diese Kette ein.

34:57.500 --> 35:01.120
Das Ganze machen wir so lange, bis wir nur noch praktisch ein Zeichen

35:01.120 --> 35:04.620
übrig haben und dieses Zeichen hat dann, wenn wir alles richtig

35:04.620 --> 35:06.360
gemacht haben, die Wahrscheinlichkeit 1.

35:07.920 --> 35:12.920
Wir hatten dafür dann ein Codebaum aufgebaut, anhand dessen wir dann

35:12.920 --> 35:16.380
auch Wörter kodiert haben mit einem so entwickelten Code.

35:17.260 --> 35:19.020
Das heißt, der sah dann ungefähr so aus.

35:19.700 --> 35:24.680
Unsere Terminalzeichen standen irgendwo in den Blättern und Wege durch

35:24.680 --> 35:29.680
diesen Baum, also zum Beispiel so einer hier, RL wäre dann ein

35:29.680 --> 35:33.480
Codewort für das Zeichen B.

35:35.880 --> 35:41.080
Eine wichtige Eigenschaft noch von dem Affman-Code war, dass es ein

35:41.080 --> 35:45.260
Präfixcode ist und das bedeutete, dass eben kein Wort eines Codes

35:45.750 --> 35:49.680
Anfang eines anderen Codewortes ist, sodass wir, wenn wir irgendeine

35:49.680 --> 35:55.040
wilde Kette bekommen, die da aussieht R-L-L-R-R-R-L-R-R, dass wir das

35:55.040 --> 35:57.840
tatsächlich eindeutig wieder entschlüsseln können.

35:58.320 --> 36:03.060
Wir gucken nach, also RL, haben wir gerade schon gesehen, macht ein B,

36:03.700 --> 36:06.940
dann kommt nur ein L, weil dann fangen wir wieder oben an, nur ein L

36:06.940 --> 36:12.340
kriegen wir also ein A, dann kommt ein RR, kriegen wir ein T und so

36:12.340 --> 36:14.080
weiter, bis zum Schluss durch.

36:14.860 --> 36:18.560
Und aus dem Grund, weil es ein Präfixcode ist, funktioniert das Ganze

36:18.560 --> 36:18.920
überhaupt.

36:22.120 --> 36:26.000
Das Ganze wollen wir jetzt in Haskell einigermaßen übersichtlich

36:26.000 --> 36:26.520
hinkriegen.

36:26.600 --> 36:30.660
Wir brauchen dafür tatsächlich einiges an Codezeilen und damit es

36:30.660 --> 36:33.940
übersichtlich ist, hier dann eben die Modulstruktur.

36:35.080 --> 36:38.900
Wir wollen uns zuerst mal ein Modul definieren, was uns alle

36:38.900 --> 36:42.040
Datentypen, die wir an irgendwelchen Stellen in unserem System

36:42.040 --> 36:45.180
brauchen, definiert und die werden wir alle in Types schmeißen.

36:45.620 --> 36:49.480
Dann werden wir irgendwo ein Modul bauen, das uns Codetabellen

36:49.480 --> 36:54.060
aufbaut, was uns einen Baum aufbaut, was uns die Frequenz, also die

36:54.060 --> 36:57.060
Häufigkeit von irgendwelchen Zeichen raussucht.

36:57.140 --> 37:01.860
Wir machen ein Modul fürs Codieren von Wörtern und fürs Dekodieren und

37:01.860 --> 37:07.600
dann eben diese zwei, die noch...

37:07.600 --> 37:10.900
also einmal MakeCode, was uns dann tatsächlich eine Codetabelle und

37:10.900 --> 37:15.120
Codes zurückliefert und dann unser Main-Modul, in dem wir das Ganze

37:15.120 --> 37:16.560
dann ausprobieren wollen.

37:17.180 --> 37:18.220
So ist also der Plan.

37:18.560 --> 37:22.340
Sie sehen daran angeschrieben natürlich auch schön, dass wir hier, Sie

37:22.340 --> 37:25.920
werden sicher raten können, was das bedeuten soll, dass wir eben auch

37:25.920 --> 37:29.840
nur das dann von dem Modul, also Codetabelle von Codetabelle in

37:29.840 --> 37:33.040
MakeCode übergeben wollen und die ganzen Hilfsfunktionen eben nicht.

37:33.420 --> 37:35.860
So ist dieses Diagramm zu lesen.

37:37.360 --> 37:39.740
Also zu unserem Modultypen.

37:40.780 --> 37:49.700
Das definieren wir so, dass wir wollen exportieren einen Baum und zwar

37:49.700 --> 37:51.660
mit seinen Konstruktoren, Leaf und Node.

37:52.200 --> 37:55.600
Wir wollen einen Datentyp Bit mit den Konstruktoren L und R

37:55.600 --> 37:56.280
exportieren.

37:56.760 --> 37:59.700
Wir wollen H-Code exportieren und Table.

38:00.700 --> 38:02.080
Das wollen wir exportieren.

38:02.200 --> 38:04.120
Alles andere davon wollen wir nicht exportieren.

38:05.080 --> 38:08.240
Die Grundtypen, die wir da haben, sind also solche, dass wir uns

38:08.240 --> 38:13.480
erstmal einen Datentyp Bit definieren und das sieht einfach so aus,

38:13.540 --> 38:15.660
wir haben einfach ein L oder ein R.

38:16.780 --> 38:20.160
Wir leiten dann EQ und Show ab, damit wir dann auch ein bisschen damit

38:20.160 --> 38:23.820
umgehen können und definieren uns dann praktisch den Typ Huffman Code

38:23.820 --> 38:25.220
als Array von Bit.

38:27.360 --> 38:31.000
So, unser nächster Typ, den wir brauchen, ist die Codetabelle.

38:32.000 --> 38:35.460
Wenn wir jedes Codewort immer durch den Baum durch und so weiter, wäre

38:35.460 --> 38:36.460
ein bisschen unangenehm.

38:36.780 --> 38:40.820
Das heißt, wir wollen uns natürlich einmal eine Tabelle aufstellen, wo

38:40.820 --> 38:46.820
steht Codewort und codierter Buchstabe und das wollen wir praktisch in

38:46.820 --> 38:51.860
dieser Tabelle, die dann eine Liste von Tuppeln aus Zeichen und

38:51.860 --> 38:54.200
Huffman Code ist, aufbauen.

38:54.700 --> 38:56.360
Dann geht es einfach leichter.

38:56.840 --> 38:59.840
So, dann wollen wir noch einen Codebaum haben, den müssen wir ja

38:59.840 --> 39:04.300
aufbauen, um den Huffman Code zu erzeugen und das ist dann halt

39:04.300 --> 39:09.040
einfach eine Datenstruktur namens Tree und das ist entweder ein Blatt

39:09.040 --> 39:13.200
und ein Blatt besteht aus einem Zeichen und der auftretenden

39:13.200 --> 39:20.580
Häufigkeit oder es ist eben ein Knoten in dem Baum und dann haben wir

39:20.580 --> 39:27.020
zwei Unterbäume und die zusammengezählte Häufigkeit ist dann auch noch

39:27.020 --> 39:27.260
drin.

39:27.460 --> 39:29.300
Dafür leiten wir dann das Show noch ab.

39:31.080 --> 39:34.520
So, unser nächstes Modul war Coding.

39:35.440 --> 39:42.180
Da wollten wir Codemessage und Decodemessage exportieren und das sieht

39:42.180 --> 39:43.000
dann so aus.

39:43.140 --> 39:46.780
Erstmal müssen wir natürlich die Typen importieren.

39:46.940 --> 39:49.120
Das hat ja das Diagramm angezeigt.

39:50.060 --> 39:52.060
Das heißt, wir holen uns das hier alles rein.

39:52.760 --> 39:55.240
Das wäre natürlich genau das Gleiche gewesen, wenn wir nur geschrieben

39:55.240 --> 39:58.940
hätten Import Types ohne die Liste hinten dran, weil das auch genau

39:58.940 --> 40:04.200
die Export war, aber zu Dokumentationszwecken, damit wir nachher noch

40:04.200 --> 40:05.900
wissen, was wir davon überhaupt brauchen.

40:06.420 --> 40:09.560
Schreiben wir uns das so, kann ja auch sein, dass derjenige, der sich

40:09.560 --> 40:12.140
um Types gekümmert hat, nachher noch irgendwelche weiteren Types

40:12.140 --> 40:14.040
dazugefügt hat, die wir alle gar nicht brauchen.

40:14.480 --> 40:17.340
Wir brauchen die hier und deswegen schreiben wir es einfach dazu und

40:17.340 --> 40:17.600
fertig.

40:18.620 --> 40:21.860
Aber wie gesagt, ohne diese Liste wäre es jetzt auch nicht falsch.

40:23.380 --> 40:28.980
So, wir haben als Signaturen die Codemessage, die natürlich von einer

40:28.980 --> 40:33.760
Codier -Tabelle, also von einer Codetable zu einem gegebenen String,

40:34.320 --> 40:35.980
den das Codewort ausgibt.

40:36.740 --> 40:40.960
Und die Code macht praktisch genau das Umgekehrte mit einem Baum und

40:40.960 --> 40:43.000
einem Code gibt es uns dann den String zurück.

40:43.960 --> 40:47.560
Zur Implementierung, die gibt es dann heute auf dem Übungsblatt.

40:48.680 --> 40:53.340
Das ist eine etwas größere Aufgabe, ist aber durch die Modularisierung

40:53.340 --> 40:55.520
sehr schön Schritt für Schritt zu lösen.

40:59.590 --> 41:02.990
Noch ein bisschen als Hilfestellung, wie gehen wir denn mit diesen

41:02.990 --> 41:03.990
Datenstrukturen um?

41:04.090 --> 41:06.990
Wie kommen wir denn da überhaupt zu dem richtigen Algorithmus?

41:07.070 --> 41:08.030
Wie funktioniert das alles?

41:09.030 --> 41:10.630
Schauen wir es uns mal am Beispiel an.

41:10.770 --> 41:17.390
Also wir geben uns vor, ein Wort, das zu codieren wäre, buttert und

41:17.390 --> 41:20.090
frage, wie wir da zu einem optimalen Code kommen.

41:22.110 --> 41:25.410
Der erste Schritt ist, dass wir natürlich die Häufigkeiten bestimmen

41:25.410 --> 41:29.530
der einzelnen Buchstaben und uns das am besten in eine Liste schreiben

41:29.530 --> 41:33.430
und dann sehen wir, machen uns Tuppel da rein, der Buchstabe B kommt

41:33.430 --> 41:37.150
einmal vor, der Buchstabe A kommt zweimal vor und der Buchstabe T

41:37.150 --> 41:38.270
kommt dreimal vor.

41:39.510 --> 41:45.030
Der nächste Schritt wäre dann, dass wir jedes der Tuppel in ein

41:45.030 --> 41:49.910
kleines initiales Bäumchen verwandeln und wir dann im Endeffekt keine

41:49.910 --> 41:52.490
Liste von Tuppeln mehr haben, sondern eine Liste von Bäumchen.

41:52.490 --> 41:57.150
Nämlich einmal Leaf B1, also Sie erinnern sich, das Zeichen und dessen

41:57.150 --> 42:02.230
Häufigkeit, noch ein Blatt A und die Häufigkeit 2 und noch ein Blatt T

42:02.230 --> 42:03.450
und die Häufigkeit 3.

42:05.110 --> 42:09.410
Der darauf folgende Schritt wäre dann eben der große Schritt, das

42:09.410 --> 42:12.230
Verschmelzen die Bäume, und zwar schrittweise.

42:14.210 --> 42:18.430
Wir suchen uns die zwei Bäume mit den geringsten Häufigkeiten aus der

42:18.430 --> 42:19.030
Liste raus.

42:19.030 --> 42:20.990
Das da oben in dem Fall.

42:24.270 --> 42:27.390
Wir fassen die beiden dann zu einem neuen Baum zusammen.

42:28.970 --> 42:34.010
Diesen neuen Baum, da berechnen wir dann, Sie erinnern sich an die

42:34.010 --> 42:37.850
Signatur, wir hatten die zusammengezählte Häufigkeit vorne mit drin

42:37.850 --> 42:41.010
stehen, die berechnen wir eben und schreiben die vorne mit in den Baum

42:41.010 --> 42:41.830
beim Erzeugen.

42:42.270 --> 42:46.530
Und dann fügen wir den Baum an der entsprechenden Stelle in der Liste

42:46.530 --> 42:46.890
ein.

42:47.430 --> 42:51.850
Entsprechende Stelle bedeutet dann natürlich sortiert nach Häufigkeit,

42:52.850 --> 42:54.110
nach auftretender Häufigkeit.

42:56.290 --> 42:59.370
So, und das Ganze, diesen Schritt davor machen wir so lange, bis es

42:59.370 --> 43:02.110
nur noch einen einzigen Baum gibt in der Liste und dann haben wir

43:02.110 --> 43:03.750
unseren Huffman-Baum aufgebaut.

43:05.410 --> 43:08.350
So, gucken wir uns das mal am Beispiel Schritt für Schritt an.

43:09.290 --> 43:14.010
Wir gehen aus von unserer Liste mit den initialen Bäumchen.

43:15.210 --> 43:18.130
Als erstes entfernen wir eben die mit der kleinsten Wahrscheinlichkeit

43:18.130 --> 43:22.090
raus, also den da und den da, das wären diese beiden und übrig bleibt

43:22.090 --> 43:24.790
dann die Liste, wo eben nur noch dieses Bäumchen drin steht.

43:26.290 --> 43:30.510
Wir machen den neuen Baum, das heißt in dem Fall, weil wir ja dann

43:30.510 --> 43:34.210
schon zwei Teilbäume haben, ein Node und daran werden zwei Blätter

43:34.210 --> 43:34.650
gehängt.

43:35.710 --> 43:40.170
Frage ist noch, was ist die zusammengezählte Wahrscheinlichkeit, das

43:40.170 --> 43:41.990
wäre dann die drei, die fügen wir dann auch noch ein.

43:42.070 --> 43:45.570
Das heißt, das ist unser neuer Baum, der jetzt als nächster Schritt in

43:45.570 --> 43:47.010
die Liste einzufügen wäre.

43:47.630 --> 43:50.910
Bei drei ist es dann auch egal, damit der Code rauskommt, den wir

43:50.910 --> 43:53.290
vorhin gezeigt haben, fügen wir es halt einfach vorne ein.

43:54.610 --> 43:58.470
Also der hat drei und der hat drei und wie gesagt, das Ganze machen

43:58.470 --> 44:01.710
wir, bis nur noch ein Baum übrig bleibt, dann sieht das Ergebnis so

44:01.710 --> 44:01.910
aus.

44:01.990 --> 44:05.590
Wir haben ein Node mit der Häufigkeit sechs, was auch der Länge des

44:05.590 --> 44:08.950
Strings entspricht dann natürlich in dem Fall und der ist dann eben

44:08.950 --> 44:14.270
dieser Teilbaum als einer Ast und das Blatt am anderen Ast.

44:16.110 --> 44:19.830
So, der nächste Schritt wäre dann, dass das nur noch in die

44:19.830 --> 44:21.290
Codetabelle umzuwandeln ist.

44:21.690 --> 44:23.530
Die sähe dazu dann natürlich so aus.

44:23.910 --> 44:27.270
B, L, L, A, L, R, T, R.

44:28.690 --> 44:31.370
Und das wäre dann eben auch von Ihnen zu erledigen.

44:32.530 --> 44:34.350
So, zur SQL.

44:35.050 --> 44:37.170
Wir haben eine neue Datenbank aufgesetzt.

44:38.470 --> 44:41.190
Wir haben nicht mehr ein Login für alle, sondern es gibt jetzt

44:41.190 --> 44:42.090
verschiedene Logins.

44:42.690 --> 44:46.430
Ihr Login ist Ihre Matrikelnummer und Ihr Passwort ist wie am Anfang

44:46.430 --> 44:47.490
auch Ihr Nachname.

44:48.110 --> 44:51.650
Das ändern Sie bitte und wenn Sie irgendwelche Probleme haben beim

44:51.650 --> 44:54.770
Einloggen, dann wenden Sie sich bitte an Ihren Tutor.

44:55.030 --> 44:58.790
Was ich Ihnen gleich sagen kann, ist diejenigen, die sich mit S, Ös,

44:58.910 --> 45:01.870
Üs oder scharfen S eingetragen haben, die werden wahrscheinlich

45:01.870 --> 45:03.370
Probleme haben beim Einloggen.

45:05.190 --> 45:06.850
Also dann bitte gleich an den Tutor.

45:07.310 --> 45:10.730
Ihr Tutor hat Administrationsrechte für die ganze Sache, kann Ihnen

45:10.730 --> 45:11.410
das anpassen.

45:12.730 --> 45:15.890
Wir haben das jetzt so eingerichtet, dass jeder seine eigene Datenbank

45:15.890 --> 45:16.190
hat.

45:16.890 --> 45:19.530
Die Datenbank heißt genauso wie die eigene Matrikelnummer.

45:20.890 --> 45:24.490
Und egal, ob wir das Ding jetzt hinreichend sicher gepflegt haben oder

45:24.490 --> 45:27.270
nicht, bitte arbeiten Sie in Ihrer eigenen Datenbank.

45:28.250 --> 45:31.210
Sie besitzen dafür auch in Ihrer eigenen Datenbank alle Rechte.

45:31.370 --> 45:34.170
Sie können also Tabelle anlegen, löschen, ändern und so weiter.

45:34.270 --> 45:37.430
Sie können Ihre Datensätze manipulieren, wie Sie das wollen.

45:37.890 --> 45:39.430
Also an dieser Stelle nochmal der Hinweis.

45:39.490 --> 45:40.530
Wir haben es nochmal aufgesetzt.

45:40.950 --> 45:42.070
Sie können gerne damit üben.

45:42.450 --> 45:43.110
Lassen Sie es ganz.

45:43.190 --> 45:44.590
Wenn es nochmal kaputt ist, bleibt es so.

45:47.310 --> 45:53.770
So, da wir ja jetzt 650 Datenbanken angelegt haben, hatte ich da jetzt

45:53.770 --> 45:56.470
irgendwie nicht so die Lust, in jede dieser einzelnen Datenbanken das

45:56.470 --> 45:57.310
Ding da einzufügen.

45:58.310 --> 46:02.410
Und da Sie die Datenbank gegebenenfalls, wenn Sie sie absichtlich oder

46:02.410 --> 46:05.610
unabsichtlich kaputt gemacht haben, sowieso brauchen, können Sie es

46:05.610 --> 46:08.150
auch im ersten Schritt gleich selber machen, sich die Datenbank

46:08.150 --> 46:08.690
installieren.

46:09.250 --> 46:12.870
Also, auf unserem Webserver, in diesem hier angegebenen Verzeichnis,

46:13.010 --> 46:14.470
finden Sie eine ZIP-Datei.

46:14.950 --> 46:18.590
Die laden Sie sich herunter, packen Sie aus, die öffnen Sie in Ihrem

46:18.590 --> 46:20.990
Texteditor und kopieren den kompletten Text.

46:21.890 --> 46:26.710
Dann loggen Sie sich in die Webseite ein, machen sich dieses kleine

46:26.710 --> 46:31.510
SQL -Fenster auf, fügen da einfach mit STRG-V alles ein, klicken auf

46:31.510 --> 46:34.010
Go, warten einen Moment und sind glücklich.

46:34.770 --> 46:37.110
Sie sind vor allem glücklich, wenn dann diese Meldung kommt.

46:37.230 --> 46:40.710
Wenn sie nicht kommt, wenden Sie sich an Ihren Tutor.

46:41.410 --> 46:45.430
So, für die unter Ihnen, die das noch nicht wissen, 50% von Ihnen

46:45.430 --> 46:47.690
wissen das ja auf jeden Fall schon, da bin ich mir ganz sicher.

46:48.310 --> 46:51.530
Sie können natürlich neue Tabellen immer nur anlegen, wenn die alten

46:51.530 --> 46:52.310
nicht mehr da sind.

46:52.690 --> 46:56.130
Also, schmeißen Sie die alten, wenn Sie die Datenbank wieder frisch

46:56.130 --> 46:57.190
machen wollen, vorher raus.

46:57.290 --> 46:59.490
Da gibt es neben jedem Tabellenname so ein Knöpfchen Drop.

46:59.690 --> 47:01.630
Da klicken Sie drauf, dann sind Sie die los.

47:03.250 --> 47:04.330
So, so kommen Sie da dran.

47:04.810 --> 47:09.670
Im Moment gibt es leider alle zwei Stunden hängt sich der Webserver

47:09.670 --> 47:10.190
wieder auf.

47:10.870 --> 47:11.490
Fragen Sie sich warum.

47:11.490 --> 47:15.830
Ich hoffe, dass Sie das geregelt kriegen bis heute Abend oder sowas in

47:15.830 --> 47:16.210
der Richtung.

47:18.430 --> 47:18.830
Gut.

47:20.670 --> 47:23.250
Wir wollen noch ein bisschen mit SQL weitermachen.

47:24.810 --> 47:29.850
Und zwar wollen wir uns verschachtelte Anfragen anschauen und da in

47:29.850 --> 47:32.430
besonderen die Keywörter in und any.

47:33.730 --> 47:37.090
Also schauen wir uns die Schachtelung mittels any Klausel an.

47:40.590 --> 47:44.230
Dieses Theta any, das heißt Theta steht jetzt wieder für irgendeinen

47:44.230 --> 47:47.330
Vergleich, also zum Beispiel ist gleich, größer gleich, kleiner

47:47.330 --> 47:49.010
gleich, ungleich, irgendwas.

47:49.990 --> 47:58.150
Any qualifiziert ein äußeres Tuppel bei einer Select-Anfrage für das

47:59.070 --> 48:05.290
der Vergleich mit irgendeinem Tuppel, deswegen any in der inneren

48:05.290 --> 48:09.930
Schachtel, also einer inneren SQL-Anfrage positiv ausfallen muss.

48:11.070 --> 48:14.410
Klingt jetzt ein bisschen abstrakt, ist aber nicht schwer.

48:15.690 --> 48:18.510
Wir wollen uns jetzt hier an dieser Stelle mal alle Kategorien

48:18.510 --> 48:21.730
ausgeben, von denen mindestens ein Artikel existiert.

48:22.030 --> 48:26.210
Das heißt, wir holen uns aus der Kategorie, aus der Tabelle Kategorie

48:26.210 --> 48:32.030
alle Daten raus und zwar genau da, wo die Kategorienummer das gleiche

48:32.030 --> 48:35.410
ist, wie irgendeiner von den Datensätzen, die wir hier innen drin

48:35.410 --> 48:39.230
selektieren und hier holen wir uns alle Kategoriennummern aus der

48:39.230 --> 48:40.610
Tabelle Artikel raus.

48:41.530 --> 48:45.010
Also, das macht natürlich, wenn diese Kategorie hier einmal drin

48:45.010 --> 48:48.070
vorkommt, dann wird die Kategorie ausgegeben.

48:48.690 --> 48:51.530
Tut also, was wir wollen und Sie sehen, Sie verwenden einfach dieses

48:51.530 --> 48:52.370
ist gleich any.

48:54.030 --> 48:58.790
Für den Fall ist gleich any gibt es in SQL eine Abkürzung, die nennt

48:58.790 --> 49:01.910
sich in und das lässt sich dann eigentlich noch ein bisschen besser

49:01.910 --> 49:02.370
lesen.

49:02.710 --> 49:06.670
Select Stern vom Kategorien, wer Kartnummer in, select

49:06.670 --> 49:09.170
Kategorienummer, also Kartnummer vom Artikel.

49:10.150 --> 49:13.510
Lässt sich in dem Fall besser lesen, geht aber eben nur für ist gleich

49:13.510 --> 49:13.710
any.

49:13.830 --> 49:17.250
Wenn Sie größer, kleiner, irgendwas haben wollen, müssen Sie es halt

49:17.250 --> 49:17.890
mit any machen.

49:19.690 --> 49:22.150
Wo ein any ist, ist ein all natürlich nicht weit.

49:23.290 --> 49:28.990
Es gibt genauso ein teter all und dort wird das äußere Tuppel nur in

49:28.990 --> 49:32.350
die Ergebnisrelation übernommen, wenn es den Vergleich mit allen

49:32.350 --> 49:36.670
Tuppeln in der inneren Schachtel besteht.

49:37.750 --> 49:40.750
Als Beispiel in dem Fall genau das Gegenteil.

49:41.090 --> 49:43.670
Kategorien, von denen kein einziger Artikel existiert.

49:44.150 --> 49:49.170
Das heißt, select Stern vom Kategorien, wer Kartnummer, ungleich all,

49:49.510 --> 49:51.330
select Kartnummer vom Artikel.

49:51.490 --> 49:54.230
Also, wir kriegen hier dann alle Kategoriennummern, die irgendwo in

49:54.230 --> 49:57.990
der Tabelle Artikel auftauchen und wenn Kartnummer ungleich alle

49:57.990 --> 50:02.210
dieser Kategoriennummern ist, dann ist es ein Kandidat, den wir

50:02.210 --> 50:03.050
ausgeben wollen.

50:04.390 --> 50:07.350
Auch hierfür gibt es natürlich wieder eine Abkürzung, die sich besser

50:07.350 --> 50:07.970
lesen lässt.

50:08.710 --> 50:12.010
Not in ist das gleiche wie nicht gleich all.

50:12.390 --> 50:15.450
Also, der Fall da oben und dann sieht oben das Statement so aus.

50:15.570 --> 50:19.530
Select Stern vom Kategorien, wer Kartnummer, not in, select Kartnummer

50:19.530 --> 50:20.370
vom Artikel.

50:21.730 --> 50:24.650
Und Sie sehen ein, wie gesagt, an dieser Stelle wieder nur das

50:24.650 --> 50:25.310
Nichtgleich.

50:25.710 --> 50:28.670
Wenn Sie hier ein Größer, ein Kleiner oder irgendwas haben, können Sie

50:28.670 --> 50:29.650
es wieder nicht ersetzen.

50:33.240 --> 50:35.340
So, das sollten Sie auch üben.

50:38.400 --> 50:40.820
Die Gelegenheit dazu haben Sie ja jetzt.

50:41.480 --> 50:45.680
Wir haben noch eine dritte Möglichkeit, die Anfragen zu verschachteln,

50:46.500 --> 50:48.040
und zwar mit Exists.

50:49.320 --> 50:52.120
Und das möchte ich mal an einem Beispiel aufziehen.

50:53.220 --> 50:56.460
Gib die höchsten Frachtkosten aus, die jemals bezahlt wurden von

50:56.460 --> 50:57.340
irgendeinem Kunden.

50:58.400 --> 51:01.280
Die Funktion Max darfst du dabei aber nicht verwenden.

51:01.720 --> 51:02.460
Wie machen wir das?

51:02.880 --> 51:05.380
Also, sagen wir mal, mit Max wäre es ja ziemlich einfach.

51:05.780 --> 51:08.720
Dann würden wir sagen, select Max Frachtkosten von Bestellung.

51:09.240 --> 51:11.540
Jetzt müssen wir das halt irgendwie anders hinkriegen, da wir Max

51:11.540 --> 51:12.580
nicht verwenden dürfen.

51:13.700 --> 51:17.840
Das heißt, mit unserem Theta All würden wir das dann so bauen.

51:18.300 --> 51:21.900
Select Frachtkosten von Bestellung, und zwar denn, wenn Frachtkosten

51:21.900 --> 51:27.280
von diesem Tuppel größer sind als alle anderen Frachtkosten von

51:27.280 --> 51:30.940
irgendwelchen, oder größer gleich, alle anderen Frachtkosten von

51:30.940 --> 51:32.160
irgendwelchen Bestellungen.

51:32.780 --> 51:34.280
So ginge das mit Theta All.

51:34.860 --> 51:37.960
Jetzt ist aber die Frage, ob wir dann nicht auch einfach die Existenz

51:37.960 --> 51:40.700
eines prüfen können, der größer ist.

51:40.700 --> 51:46.100
Ja, und das würden wir dann in dem Fall genau so machen, mit dem

51:46.100 --> 51:50.560
Exists, und zwar select Frachtkosten von Bestellung B1.

51:50.840 --> 51:56.320
Where not exists, select Stern von Bestellung B2, und dann nehmen wir

51:56.320 --> 52:01.600
hier alle Bestellungen wieder und vergleichen die mit den B1

52:01.600 --> 52:02.400
Frachtkosten.

52:02.520 --> 52:06.820
Sie sehen also, wir haben hier eine Verschränkung zwischen diesen

52:06.820 --> 52:09.800
beiden Tabellen, was auch so ein bisschen dafür sorgt, dass uns dann

52:09.800 --> 52:17.060
die Performance oft in die Knie geht bei solchen Anfragen, und wir

52:17.060 --> 52:20.880
prüfen jetzt hier an der Stelle einfach, ob wir einen finden, der eben

52:20.880 --> 52:25.300
größer ist als die Frachtkosten von unserem aktuellen Datensatz.

52:25.400 --> 52:27.780
Wenn dem so ist, geben wir es nicht zurück.

52:29.340 --> 52:33.380
Also so können wir einfach auf die Existenz prüfen mit dem

52:33.380 --> 52:34.640
Schlüsselwort Exists.

52:35.600 --> 52:39.760
Wir haben uns jetzt diese Existenzquantifizierung angeguckt, also

52:39.760 --> 52:44.280
select Frachtkosten von Bestellung B1, where exists, dann irgendeiner

52:44.280 --> 52:49.380
in dem Fall suchen wir mal irgendwelche Frachtkosten raus, die nicht

52:49.380 --> 52:53.740
die größten Frachtkosten sind, würden wir mit Exists so darstellen.

52:54.600 --> 52:59.200
Jetzt ist aber der Fall, dass Sie Existenzquantifizierung auch

52:59.200 --> 53:00.200
implizit machen können.

53:00.300 --> 53:02.840
Das können Sie eben nicht nur explizit über dieses Exists machen,

53:03.340 --> 53:05.220
sondern auch über ein Join.

53:06.180 --> 53:09.080
Sie bilden das Kreuzprodukt an dieser Stelle.

53:09.600 --> 53:12.620
Sie müssen an dieser Stelle Alias vergeben, weil Sie ja sonst nicht

53:12.620 --> 53:16.900
eindeutig referenzieren können, worauf Sie sich bezeichnen können.

53:17.940 --> 53:22.260
Und dort suchen Sie jetzt einfach alle die raus, wo eben noch ein

53:22.260 --> 53:25.780
größeres existiert in der Relation Bestellungen.

53:26.120 --> 53:28.920
Das leistet also genau das Gleiche wie da oben.

53:29.760 --> 53:35.840
Und für alle Tabellen, die hier oben in dem Select nicht mehr

53:35.840 --> 53:40.440
auftauchen, das ist quasi dann die implizite Existenzquantifizierung.

53:42.380 --> 53:46.900
Da prüfen Sie ja nur, wenn der Join nicht klappt, fliegt Ihr Datensatz

53:46.900 --> 53:49.600
ja raus, wenn ich keinen dazu passenden finde, sodass ich es

53:49.600 --> 53:50.580
aneinander hängen kann.

53:51.300 --> 53:54.400
Wenn ich einen finde, verwerte ich ja die Ergebnisse nicht.

53:55.340 --> 53:59.220
Ich gebe ja nichts davon weiter an den Darüberliegenden.

53:59.680 --> 54:02.940
Das heißt, das ist wirklich nur die Prüfung, ist einer da oder ist

54:02.940 --> 54:03.540
keiner da.

54:03.680 --> 54:06.880
Deswegen die implizite Existenzquantifizierung.

54:07.000 --> 54:08.400
Die sollten Sie dann unterscheiden können.

54:10.360 --> 54:14.280
So, was wir uns noch anschauen wollen, ist jetzt die Manipulation von

54:14.280 --> 54:15.500
Daten in SQL.

54:16.620 --> 54:20.020
Die Syntax ist auch denkbar einfach an dieser Stelle.

54:20.580 --> 54:25.380
Wir schreiben hin Insert into Relationsname, gegebenenfalls optional

54:25.380 --> 54:29.960
schreiben wir noch eine Attributliste dazu und können dann entweder

54:29.960 --> 54:34.640
Values mit einer Wertliste oder eine Selectanweisung dahinter

54:34.640 --> 54:35.080
schreiben.

54:38.640 --> 54:44.280
Wichtig anzumerken ist hier, dass jede Anfügeanweisung sich immer nur

54:44.280 --> 54:47.540
auf eine einzige Relation, und zwar die mit dem Relationsname hier

54:47.540 --> 54:48.880
oben bezieht.

54:50.080 --> 54:54.140
Sie können hier oben keine, also Sie würden ja vielleicht sagen,

54:54.240 --> 54:55.260
Relationale Algebra.

54:55.440 --> 54:57.780
Wir können hier oben dann einfach wieder eine Relation reinschreiben,

54:57.940 --> 55:01.320
also möglicherweise auch irgendein Selectergebnis.

55:02.180 --> 55:06.420
Zum einen wird es natürlich schwierig, zum anderen, weil wo gehen dann

55:06.420 --> 55:07.940
die Daten hin, das ist nicht definiert.

55:08.100 --> 55:12.540
Zum anderen ist es halt auch so, dass gerade wenn Sie an Dinge wie

55:12.540 --> 55:15.720
Schlüsselbedingungen, Fremdschlüsselbedingungen und sowas denken,

55:16.140 --> 55:19.540
können Sie nicht in beliebigen Kombinationen alles überall einfügen.

55:19.920 --> 55:23.880
Dafür gibt es aber dann auch wieder Theorien mathematischer Natur,

55:24.500 --> 55:28.380
grafentheoretischer Natur, die Ihnen dann sagen, wann es theoretisch

55:28.380 --> 55:29.780
wäre, etwas einzufügen.

55:30.220 --> 55:35.840
Praktisch lässt es aber kaum ein Datenbankprodukt zu, dass Sie in eine

55:35.840 --> 55:42.160
Sicht, in ein View, also in ein festgelegtes Select-Statement in

55:42.160 --> 55:46.000
irgendeiner Form Daten einfügen oder Daten editieren, wenn es aus mehr

55:46.000 --> 55:47.200
als einer Tabelle kommt.

55:51.660 --> 55:55.280
An dieser Stelle wichtig zu erwähnen, dass wenn Sie eben nicht alle

55:55.280 --> 55:59.940
Tuppel -Elemente belegen möchten, dann können Sie einfach mit dieser

55:59.940 --> 56:04.120
Attributliste sagen, ich möchte nur die Tuppel-Komponente 1., 2., 3.

56:04.360 --> 56:05.680
oder 1., 5., 7.

56:05.900 --> 56:09.640
oder so belegen und dann muss Ihre Wertliste auch entsprechend darauf

56:09.640 --> 56:10.460
angepasst sein.

56:10.800 --> 56:14.060
Die restlichen Werte werden dann auf 0 gesetzt, diesen speziellen

56:14.060 --> 56:16.920
Wert, den ich das letzte Mal schon mal erwähnt habe, zu dem ich aber

56:16.920 --> 56:19.100
auf der nächsten Folie noch ein bisschen mehr sagen werde.

56:21.740 --> 56:25.580
Ohne Attributliste müssen die eingefügten Tuppel zum Schema der

56:25.580 --> 56:26.940
Relation kompatibel sein.

56:27.480 --> 56:33.240
Mit Attributliste müssen die Tuppel kompatibel zum Schema der

56:33.240 --> 56:35.220
projizierten Relation sein.

56:35.220 --> 56:36.860
Das ist natürlich klar.

56:37.000 --> 56:40.440
Sie müssen darauf achten, dass Sie nur ganze Zahlen in Felder

56:40.440 --> 56:43.160
reinstecken, in die nur ganze Zahlen können.

56:43.700 --> 56:46.440
Sie müssen auf die Anzahl der Tuppel, die hier hinten dann eben

56:46.440 --> 56:49.500
stehen, in der Select-Anweisung oder in der Wertliste, dass die da

56:49.500 --> 56:50.280
oben reinpassen.

56:50.620 --> 56:52.680
Und die Reihenfolge ist eben auch wichtig.

56:52.820 --> 56:55.780
Bei dem Ganzen, wichtig, müssen Sie die Konsistenzbedingungen

56:55.780 --> 56:56.240
beachten.

56:56.820 --> 57:00.280
Gerade nochmal Hinweis auf Nullwerte oder Fremdschlüssel oder

57:00.280 --> 57:02.400
sonstiges, was in der Datenbank angelegt ist.

57:03.420 --> 57:06.580
Wie Sie sehen, wir haben hier zwei Einfüge-Varianten.

57:06.740 --> 57:10.140
Das heißt, wir fügen entweder einen Einzeltuppel ein mit diesem ersten

57:10.140 --> 57:14.440
Fall, mit diesem Values oder wir fügen dann gleich eine ganze

57:14.440 --> 57:18.100
Tuppelmenge ein, indem wir da oben ein Select definieren.

57:21.650 --> 57:22.670
Zu Nullwerten.

57:23.070 --> 57:26.850
Es kann sein, dass ich jetzt in meiner Anwendung einen Benutzer nicht

57:26.850 --> 57:31.170
zwingen will, einen Wert gleich für alle Tuppel anzugeben.

57:31.290 --> 57:34.150
Vielleicht gibt es für eine Komponente gar keinen Wert.

57:34.790 --> 57:36.890
Vielleicht will man den jetzt noch nicht eingeben.

57:37.950 --> 57:41.030
Ein Beispiel dafür wäre, wenn wir jetzt hier eine Relation Person

57:41.030 --> 57:41.510
haben.

57:42.490 --> 57:44.690
Die hat einen Namen, Middle Initial und Given Name.

57:45.950 --> 57:50.090
Wie es ja in Amerika üblich ist mit dem Middle Initial.

57:51.110 --> 57:53.930
Und da ist es ganz günstig, wenn man kein Middle Initial hat, dass man

57:53.930 --> 57:55.730
da an der Stelle Null eingeben kann.

57:56.350 --> 57:59.850
Man könnte natürlich sagen, man gibt pauschal Leerzeichen ein oder

57:59.850 --> 58:00.330
sonst irgendwas.

58:00.550 --> 58:01.930
Das ist ja eigentlich nicht, was wir wollen.

58:01.990 --> 58:03.630
Wir wollen an dieser Stelle sagen, nichts.

58:04.210 --> 58:06.370
Und Null gibt eben genau dieses Nichts an.

58:07.550 --> 58:11.850
Die Theorie zu den Nullwerten, die finden Sie in Kapitel 2a auf Folie

58:11.850 --> 58:14.230
69, Stichwort flachgeordnete Mengen.

58:14.330 --> 58:16.910
Sie erinnern sich, habe ich auch letztes Mal schon mal auf die Folie

58:16.910 --> 58:17.410
gemalt.

58:18.930 --> 58:22.270
Null, eben wegen dieser Eigenschaft, passt überall.

58:22.410 --> 58:25.250
Null können Sie in Float-Spalten einsetzen, in Integer-Spalten,

58:25.690 --> 58:27.810
Varchar, Date und so weiter.

58:30.030 --> 58:33.450
Und Null dürfen Sie auch standardmäßig überall reinstecken.

58:34.190 --> 58:36.490
Also der Standard ist, dass Sie es überall reinstecken können.

58:37.870 --> 58:41.890
Was aber der Fall ist, ist, dass Sie es explizit als derjenige, der

58:41.890 --> 58:46.790
die Tabelle manipulieren kann, nicht die Datensätze selbst, wenn Sie

58:46.790 --> 58:50.350
die Tabelle manipulieren können, dann können Sie ausschließen, dass

58:50.350 --> 58:54.230
man irgendwo Nullwerte eintragen darf, wenn Sie nämlich bei der

58:54.230 --> 58:56.630
Schemadefinition Not Null angeben.

58:57.210 --> 59:00.610
Und das ist bei einigen Feldern auch tatsächlich so gemacht, in der

59:00.610 --> 59:03.310
Datenbank, die zur Verfügung steht.

59:03.630 --> 59:06.990
Wenn also hier Not Null steht und Sie versuchen, irgendwas einzufügen

59:06.990 --> 59:12.550
und dann kommt irgendwie ein Wert zurück, ein Fehler mit Null, dann

59:12.550 --> 59:15.850
sollten Sie ganz schleunigst gucken, ob Sie nicht versuchen, in ein

59:15.850 --> 59:21.710
Feld, was Not Null gesetzt hat, Null einzufügen.

59:22.750 --> 59:26.250
An dieser Stelle nochmal den Hinweis, Sie erinnern sich, A Nummer war

59:26.250 --> 59:30.470
natürlich unser Primärschlüssel und in dem Fall macht es vielleicht

59:30.470 --> 59:33.110
tatsächlich Sinn, dass wir fordern, dass man für den Primärschlüssel

59:33.110 --> 59:34.970
auf jeden Fall was einträgt.

59:37.350 --> 59:41.510
Sinnvoll wäre es sicher auch noch hier eins zu fordern, dass bei

59:41.510 --> 59:46.350
Artikel Name zumindest Not Null drinsteht, aber das kann man sich dann

59:46.350 --> 59:47.450
im Einzelnen überlegen.

59:47.590 --> 59:50.030
Beim Primärschlüssel ist es aber wichtig, dass wir da einen Wert

59:50.030 --> 59:50.330
haben.

59:51.550 --> 59:56.410
So, ein anderes Beispiel mit dem Insert, das haben wir gerade gesehen,

59:56.890 --> 01:00:00.190
für Select sieht das Ganze dann so aus.

01:00:00.670 --> 01:00:03.410
Select, Stern, Form, Person, where middle initial is Null.

01:00:03.710 --> 01:00:08.210
Aha, also wir können mit dem Null auch tatsächlich vergleichen und in

01:00:08.210 --> 01:00:10.010
unserer Where-Clause umgehen.

01:00:10.590 --> 01:00:14.510
Optional können wir auch auf Is Not Null, also irgendwas anderes als

01:00:14.510 --> 01:00:15.150
Null prüfen.

01:00:16.350 --> 01:00:22.010
So, ein paar Beispiele für das Einfügen wären diese hier.

01:00:23.250 --> 01:00:27.190
Wir fügen eine neue Kategorie in unsere Relation Kategorien ein, also

01:00:27.190 --> 01:00:32.090
ganz einfach Syntax, Insert into Kategorien, Values und dann unser

01:00:32.090 --> 01:00:35.930
Tuppel, was wir einfügen wollen, Neun, Sie erinnern sich, die erste

01:00:35.930 --> 01:00:39.170
Spalte war die Kategorie Nummer, dann der Kategorie Name, da wollen

01:00:39.170 --> 01:00:42.450
wir dann Ersatzteile einfügen und dann irgendwelche Zündkerzen usw.

01:00:42.570 --> 01:00:43.390
als Beschreibung.

01:00:44.750 --> 01:00:49.950
Sie sehen an dieser Stelle wieder, die Reihenfolge äußerst wichtig,

01:00:50.050 --> 01:00:53.390
wir müssen uns genau an die Definitionsreihenfolge im Schema

01:00:53.390 --> 01:00:54.670
Kategorien halten.

01:01:08.010 --> 01:01:09.750
Also Reihenfolge und Anzahl.

01:01:10.270 --> 01:01:12.850
Und Typen sehen Sie natürlich auch ein, hier vorne kann ich kein

01:01:12.850 --> 01:01:13.950
String einfügen, da hinten.

01:01:17.110 --> 01:01:18.930
Also seien Sie nochmal dran erinnert.

01:01:20.010 --> 01:01:25.010
Nächstes Beispiel, ein bisschen größer, weil wir jetzt an der Stelle

01:01:25.010 --> 01:01:29.270
mal nicht einen Einzelwert einfügen wollen, sondern...

01:01:35.530 --> 01:01:37.330
Was gehen Sie denn heute Abend im Kino angucken?

01:01:39.830 --> 01:01:40.310
Pornos?

01:01:44.080 --> 01:01:47.040
Wir haben so hübsche Damen hier zwischendrin sitzen.

01:01:53.300 --> 01:01:56.140
Halt die Schnauze, das war, nein, nicht gut.

01:01:56.340 --> 01:02:00.080
Nein, kaufen Sie Blumen und beeindrucken Sie.

01:02:02.160 --> 01:02:04.320
Oder lernen Sie Informatik, das wäre noch viel besser.

01:02:05.120 --> 01:02:06.320
Wir schreiben bald eine Klausur.

01:02:06.940 --> 01:02:09.040
Gut, bitte?

01:02:11.720 --> 01:02:12.120
Nicht?

01:02:12.580 --> 01:02:13.340
Schreiben Sie keine?

01:02:13.960 --> 01:02:16.160
Doch, gut, das würde ich doch so hören.

01:02:16.600 --> 01:02:19.540
Gut, also wir wollen jetzt mal was einfügen und zwar mit Select

01:02:19.540 --> 01:02:23.300
Statement und bitte noch ein bisschen den Lärmpegel, danke.

01:02:30.210 --> 01:02:31.910
Hätte ich mich nicht so schnell bedanken sollen.

01:02:52.040 --> 01:02:56.540
Also, wir wollen uns jetzt mal ein Beispiel angucken, wo wir etwas in

01:02:56.540 --> 01:03:00.780
die Tabelle Kategorien einfügen wollen und zwar nicht über den

01:03:00.780 --> 01:03:04.080
Ausdruck hier mit Values, also ein Einzeltuppel, sondern mehrere

01:03:04.080 --> 01:03:04.540
Tuppel.

01:03:05.200 --> 01:03:08.100
Und wir nehmen jetzt hier in dem Fall mal an, dass wir noch eine

01:03:08.100 --> 01:03:13.600
andere Tabelle hätten, die heißt vorbereitete Kategorien und dort

01:03:13.600 --> 01:03:18.620
wäre, die habe also genau ein identisches Schema und dort wären

01:03:18.620 --> 01:03:21.880
irgendwelche Kategorien, die wir jetzt in die Tabelle Kategorien

01:03:21.880 --> 01:03:24.260
einfügen wollen, schon vorbereitet.

01:03:24.560 --> 01:03:27.740
Das Ganze würde dann also so aussehen, Insert in die Kategorien,

01:03:28.380 --> 01:03:32.880
Select Stern vom vorbereitete Kategorien, in dem Fall Where Kategorien

01:03:32.880 --> 01:03:33.440
gleich 9.

01:03:33.820 --> 01:03:36.940
Wir könnten aber auch sagen, zwischen 9 und 25 oder sonst irgendwie,

01:03:37.020 --> 01:03:41.960
Sie sehen einen, wir können damit 1 einfügen, 2, 5, 0 und 47.

01:03:43.280 --> 01:03:47.760
So, ein anderes Beispiel, an dem ich Ihnen nochmal zeigen will, dass

01:03:47.760 --> 01:03:52.780
wir dann auch implizit Nullwerte einfügen können, wie wir die

01:03:54.040 --> 01:03:58.820
Attribute referenzieren und wie wir uns zum Beispiel hier eine andere

01:03:58.820 --> 01:04:04.280
Möglichkeit als die von MySQL oder pgesql gegebenen Sequences selbst

01:04:04.280 --> 01:04:07.600
einen Primärschlüssel gleichzeitig erzeugen können, denn wir können in

01:04:07.600 --> 01:04:12.220
diesem Select Statement natürlich auf uns selber zugreifen und sagen,

01:04:12.340 --> 01:04:15.880
wir holen uns einfach das Maximum der Kategorien Nummer raus, addieren

01:04:15.880 --> 01:04:19.440
eins dazu und haben dann automatisch einen neuen Primärschlüsselwert

01:04:19.440 --> 01:04:22.500
und fügen dann die Ersatzteile mit ein.

01:04:25.920 --> 01:04:31.560
Zum Ändern von Tuppeln ist die Syntax Update Relationsname Set

01:04:31.560 --> 01:04:33.240
Attributname gleich Ausdruck.

01:04:33.640 --> 01:04:36.980
Das können Sie dann Attributname gleich Ausdruck mit Kommas getrennt

01:04:36.980 --> 01:04:42.360
beliebig oft noch wiederholen und können noch eine Where Clause

01:04:42.360 --> 01:04:44.380
angeben, um eine neue Bedingung anzugeben.

01:04:46.060 --> 01:04:51.140
Grundsätzlich gilt, dass Sie mit einem Update Statement immer Mengen

01:04:51.140 --> 01:04:52.400
von Tuppeln bearbeiten.

01:04:53.480 --> 01:04:56.780
Sie können aber natürlich mittels der Where Clause auch zu einer Null-

01:04:56.780 --> 01:04:58.540
oder einereinelementigen Menge kommen.

01:04:58.980 --> 01:05:02.060
Wenn Sie eine einelementige Menge, dann bearbeiten Sie also genau ein

01:05:02.060 --> 01:05:03.640
Tuppel, was Sie gerade bearbeiten wollen.

01:05:06.700 --> 01:05:09.680
Das habe ich eben gesagt, dass Sie das genau mit der Where Clause

01:05:09.680 --> 01:05:10.740
machen können.

01:05:11.880 --> 01:05:15.180
Wichtig auch wieder bei Update ist, dass Sie die Konsistenzbedingungen

01:05:15.180 --> 01:05:15.620
beachten.

01:05:16.220 --> 01:05:20.060
Denn wenn Sie jetzt anfangen, irgendwelche Primärschlüssel zu ändern

01:05:20.060 --> 01:05:23.900
und die sind möglicherweise Fremdschlüssel in den anderen Relationen,

01:05:23.900 --> 01:05:25.300
kann das Ganze heikel werden.

01:05:25.800 --> 01:05:28.740
Wir haben geschaut, dass die Datenbank, die wir Ihnen installiert

01:05:28.740 --> 01:05:32.200
haben, dass wenn Sie dann irgendwo den Primärschlüssel ändern, dass

01:05:32.200 --> 01:05:36.560
dann der referenzierende Wert, mit dem Sie ja vergleichen wollen, der

01:05:36.560 --> 01:05:38.280
eine ändert sich weg.

01:05:39.920 --> 01:05:43.440
Also Sie haben irgendeinen Wert da und einen anderen Wert, der

01:05:43.440 --> 01:05:44.540
referenziert darauf.

01:05:44.980 --> 01:05:46.120
Sie bewegen sich hier weg.

01:05:47.760 --> 01:05:52.400
Dann wird automatisch dafür gesorgt, dass Sie praktisch auch hier

01:05:52.400 --> 01:05:56.080
diesen Wert automatisch mit wegbewegen, dass dann die Referenz hier

01:05:56.080 --> 01:05:56.700
immer noch stimmt.

01:05:58.080 --> 01:06:01.980
Das ist also wichtig, gerade wenn Sie dann auch mit den Schematas

01:06:01.980 --> 01:06:03.800
anlegender Dings arbeiten.

01:06:05.180 --> 01:06:09.480
Als Beispiel sei hier folgende Aufgabe mal angegeben.

01:06:10.960 --> 01:06:14.880
Der Lieferant, naja, hätte ich was genommen, was ich lesen könnte oder

01:06:14.880 --> 01:06:16.140
aussprechen, wäre gut gewesen.

01:06:16.880 --> 01:06:19.600
Jedenfalls hat der seine Preise mal kräftig erhöht.

01:06:20.200 --> 01:06:22.920
Und das wollen wir jetzt in der Datenbank eintragen.

01:06:24.600 --> 01:06:27.740
Das Problem ist aber, dass wir so teure Artikel nicht mehr verkaufen

01:06:27.740 --> 01:06:31.860
können und aus dem Grund wollen wir die auch über kurz oder lang aus

01:06:31.860 --> 01:06:32.720
dem Sortiment kriegen.

01:06:33.440 --> 01:06:34.680
Das Ganze sieht dann so aus.

01:06:34.820 --> 01:06:36.460
Update, Relation, Artikel.

01:06:36.620 --> 01:06:37.680
Erstmal soweit, so klar.

01:06:38.240 --> 01:06:42.440
Dann wollen wir den Einzelpreis anpassen, also der hat kräftig erhöht,

01:06:42.540 --> 01:06:43.340
nämlich verdoppelt.

01:06:44.180 --> 01:06:48.060
Sie sehen, wir können auch gleich noch auf die aktuellen Werte

01:06:48.060 --> 01:06:52.340
zugreifen und das dann den Werten wieder zuweisen, die wir dann

01:06:52.340 --> 01:06:53.700
aktuell überschreiben wollen.

01:06:54.300 --> 01:06:57.040
Wir können aber das Ganze auch wesentlich einfacher machen, wenn wir

01:06:57.040 --> 01:07:00.420
einfach irgendwie eine Konstante zuweisen und sagen, dass das jetzt

01:07:00.420 --> 01:07:01.760
ein Auslaufartikel ist.

01:07:02.580 --> 01:07:08.620
Und das machen wir für genau die Lieferanten, für die gilt, tja, hier

01:07:08.620 --> 01:07:11.280
ist es dann unser In, äußerst praktisch, wenn wir das verwenden

01:07:11.280 --> 01:07:16.020
können, weil wir uns hier nämlich gerade diese eine Lieferantennummer

01:07:16.020 --> 01:07:20.860
holen, wo der Lieferantenname eben firmaunaussprechlich entspricht.

01:07:23.540 --> 01:07:27.300
Löschen ist noch einfacher, ist immer am einfachsten, da brauchen wir

01:07:27.300 --> 01:07:28.060
gar nicht viel tun.

01:07:28.520 --> 01:07:32.740
Delete from Relationsname und optional können Sie noch eine Bedingung

01:07:32.740 --> 01:07:33.560
dazu angeben.

01:07:35.540 --> 01:07:39.920
Wichtig dabei ist, dass Sie bei diesem Statement nicht mit dem

01:07:39.920 --> 01:07:43.260
kleinsten syntaktisch korrekten Ding anfangen, um es mal

01:07:43.260 --> 01:07:45.880
auszuprobieren, weil dann bleibt Ihnen nämlich nichts übrig.

01:07:46.280 --> 01:07:48.580
Wenn Sie die Where-Clause weglassen, wird alles gelöscht.

01:07:49.280 --> 01:07:53.380
Wenn Sie die Where-Clause aber angeben, dann werden nur die Tuppel

01:07:53.380 --> 01:07:56.760
gelöscht, die auch dieser Where-Clause entsprechen.

01:07:57.720 --> 01:08:01.500
Das heißt, so als kleinen Tipp würde ich Ihnen einfach empfehlen, Sie

01:08:01.500 --> 01:08:06.820
schreiben Select-Stern from Relationsname Where-Bedingung und wenn die

01:08:06.820 --> 01:08:09.440
Tuppel, die Sie dann sehen, denen entsprechen, die Sie löschen wollen,

01:08:09.540 --> 01:08:11.960
dann löschen Sie die ersten zwei Zeilen und schreiben Delete from

01:08:11.960 --> 01:08:13.000
Relationsname dahin.

01:08:13.920 --> 01:08:16.760
Dann wissen Sie auch, was Sie im nächsten Schritt löschen.

01:08:17.280 --> 01:08:20.420
Für unser Beispiel sei es so, dass Firma unaussprechlich ihre Preise

01:08:20.420 --> 01:08:25.020
nochmal erhöht hat und die Artikel wollen wir jetzt ganz aus dem

01:08:25.020 --> 01:08:25.860
Sortiment nehmen.

01:08:26.720 --> 01:08:31.440
Das heißt, Delete from Artikel Where Lieferant in und dann eben wieder

01:08:31.440 --> 01:08:34.800
unser Trick hier, wie wir an die Lieferantennummer kommen, ohne die

01:08:34.800 --> 01:08:37.760
vorher nachgeschlagen zu haben und in irgendeiner Metasprache

01:08:37.760 --> 01:08:38.940
gespeichert zu haben.

01:08:41.300 --> 01:08:44.220
Hierbei wieder wichtig, die Konsistenzbedingungen zu beachten.

01:08:44.220 --> 01:08:48.900
Das heißt, nehmen wir an, Sie haben wieder irgendeine Referenz von

01:08:48.900 --> 01:08:51.640
einem Fremdschlüssel auf Ihren Primärschlüssel und Sie fangen jetzt

01:08:51.640 --> 01:08:52.780
an, den wegzuschmeißen.

01:08:54.320 --> 01:08:57.240
Dann ist natürlich die ganz große Frage, was machen Sie hier drüben

01:08:57.240 --> 01:08:57.440
mit?

01:08:57.820 --> 01:09:00.400
Sie können da ja nicht jetzt irgendwie einen neuen Wert eintragen, das

01:09:00.400 --> 01:09:05.180
heißt, nehmen wir an, Ihr Artikel war in der Kategorie Süßwaren.

01:09:05.340 --> 01:09:08.040
Wollen Sie ihn danach in die Kategorie Fleischprodukte übernehmen?

01:09:08.380 --> 01:09:09.400
Wahrscheinlich eher nicht.

01:09:10.140 --> 01:09:12.660
Da gibt es dann unterschiedliche Strategien, wie man sich das

01:09:12.660 --> 01:09:13.440
überlegen kann.

01:09:13.820 --> 01:09:17.900
Man kann zum Beispiel sagen, man zieht das Ganze nach und löscht dann

01:09:17.900 --> 01:09:18.880
auch die hier drüben.

01:09:19.520 --> 01:09:22.780
Eine Alternative dazu wäre, dass man hier dann einfach einen Nullwert

01:09:22.780 --> 01:09:28.760
einträgt oder was auch immer Sie sich da noch ausdenken können.

01:09:29.240 --> 01:09:32.120
Aber das ist eben was, was Sie auch immer im Hinterkopf behalten

01:09:32.120 --> 01:09:32.420
müssen.

01:09:32.840 --> 01:09:34.640
Das sind Ihre Konsistenzbedingungen.

01:09:35.740 --> 01:09:38.200
Ich bedanke mich recht herzlich, wünsche Ihnen ein schönes Wochenende.

01:09:38.200 --> 01:09:39.600
Bis nächste Woche.