Datenbanken und elektronische Informationssysteme - Java

Werbung
PHBern
Abteilung Sekundarstufe I
Studienfach Informatik
Datenbanken
und elektronische Informationssysteme
Praktikum für Studierende im 4. Semester
Jarka Arnold
Februar 2012
Datenbanken
Seite 1
Inhalt
1. Was sind Datenbanken und Datenbanksysteme?............................................................ 1
1.1 Datenbanksysteme ............................................................................................................................... 1
1.2 Relationale Datenbanken ..................................................................................................................... 2
1.3 Anforderungen auf ein Datenbankmanagementsystem ....................................................................... 5
1.4 SQL....................................................................................................................................................... 6
2. MS Access 2007 ................................................................................................................. 8
2.1 Elemente eines Access-Datenbanksystems ........................................................................................ 8
2.2 Tabellenstruktur festlegen .................................................................................................................... 8
2.3 Verschiedene Ansichten ....................................................................................................................... 9
2.4 Formular erstellen................................................................................................................................. 9
2.5 Import und Export von Daten ............................................................................................................. 11
2.6 Suchen ............................................................................................................................................... 11
2.7 Abfragen ............................................................................................................................................. 12
2.8 Aktualisierungs- und Anfügeabfrage ................................................................................................. 14
2.9 Arbeit mit verknüpften Tabellen .......................................................................................................... 15
2.10 Bericht erstellen ............................................................................................................................... 16
2.11 Startformular ..................................................................................................................................... 18
2.12 Dateianlagen (z.B. Fotos) in einer Access-Datenbank speichern .................................................... 20
2.13 Zugriffskontrolle ................................................................................................................................ 21
3. MySQL ............................................................................................................................... 22
3.1 Was ist MySQL ? ................................................................................................................................ 22
3.2 MySQL Datentypen ............................................................................................................................ 22
3.3 Die wichtigsten Befehle ...................................................................................................................... 22
3.4 Eine Tabelle mit einer Scriptdatei definieren ...................................................................................... 23
3.5 phpMyAdmin ....................................................................................................................................... 24
4. Client-Server-Architektur ................................................................................................. 26
4.1 File-Server Architektur (intelligenter Client / "dummer" Server) ......................................................... 26
4.2 Intelligenter Client/Intelligenter Server ............................................................................................... 26
4.3 Webdatenbanken (Browser auf Client/ intelligenter Server) .............................................................. 27
4.4. MS-Access als Datenbank-Client, ODBC ......................................................................................... 27
4.5. Client-Datenbankapplikationen mit JDBC ......................................................................................... 29
5. Dynamische Webseiten ................................................................................................... 31
5.1 Interaktionen ....................................................................................................................................... 31
5.2 HTTP-Transaktionen .......................................................................................................................... 31
5.3 Verschiedene Technologien ............................................................................................................... 31
5.4 Datenbanken im Internet .................................................................................................................... 32
6. Java Server Pages ............................................................................................................ 33
6.1 JSP Request ....................................................................................................................................... 33
6.2 Einbettung vom Java-Code in JSP-Seiten, Syntax ............................................................................ 34
6.3 Eingabe und Ausgabe ohne Datenbankzugriff ................................................................................... 35
6.4 JSP und MySQL-Datenbanken .......................................................................................................... 38
6.5 Datenbankfunktionen, modular programmiert .................................................................................... 40
6.6 Datenbank-Grundoperationen zusammengefasst ............................................................................. 50
6.7 Zugriff mit einem Passwort schützen, Session-Variablen .................................................................. 52
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 2
7. PHP.................................................................................................................................... 54
7.1 PHP – Bedeutung ............................................................................................................................... 54
7.2 Syntax, Datentypen, Variablen, Operatoren ...................................................................................... 54
7.3 Programmsteuerung ........................................................................................................................... 56
7.4 Ausgabe-Befehle ................................................................................................................................ 57
7.5 Arrays ................................................................................................................................................. 57
7.6 Funktionen und Unterprogramme ...................................................................................................... 60
7.7 Formularauswertung mit PHP ............................................................................................................ 61
7.8 GET und POST .................................................................................................................................. 63
7.9 Weitere Formularelemente (Radio, Checkbox, Optionsliste) ............................................................. 63
7.10 Mailer (Online Mitteilung automatisch verschicken) ......................................................................... 65
8. PHP und MySQL ............................................................................................................... 67
8.1 MySQL – PHP – Funktionsbibliothek ................................................................................................. 67
8.2 Formulardaten in eine Datenbank schreiben ..................................................................................... 68
8.3 Online-Anmeldung .............................................................................................................................. 69
8.4 Online-Inventar ................................................................................................................................... 73
9. Gesellschaftliche Auswirkungen von Datenbanken ...................................................... 78
9.1 Datensicherheit ................................................................................................................................... 78
9.2 Datenschutz ........................................................................................................................................ 78
9.3 Verknüpfung von Informationen und neue Risiken ............................................................................ 79
10. Literatur: ......................................................................................................................... 81
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 1
1. Was sind Datenbanken und Datenbanksysteme?
1.1 Datenbanksysteme
In der modernen Informationsgesellschaft spielen Datenbanksysteme eine ausserordentlich
grosse Rolle. Sie ermöglichen es, Informationen strukturiert abzulegen und mit standardisierten
Suchverfahren auf die gespeicherten Daten zuzugreifen.
Die früher häufig gebrauchte Karteikartensysteme, auf denen man Informationen in den Bibliotheken, Personalämtern, Gemeindeverwaltungen usw. gesammelt hat, haben ausgedient. Die
Informationen werden heute elektronisch gespeichert.
Umgangssprachlich machen wir oft keinen Unterschied zwischen einer Datenbank und einem
Datenbanksystem. Aus technologischer Sicht versteht man unter einem Datenbanksystem ein
Gesamtsystem bestehend aus Datenbank, Datenbankverwaltungssystem (DatenbankManagement-System DBMS) und Kommunikationsschnittstelle.
Benutzer 1
Benutzer 2
Benutzer 3
Mensch
Datenbanksystem
Kommunikationsschnittstelle
Datenbankmanagementsystem
(DBMS)
Datenbanksystem
Datenbank (DB)
Daten
Die Datenbank definiert eine Komponente des Datenbanksystems, die für die systematische
Speicherung von Daten verantwortlich ist.
Das Datenbankmanagementsystem ist eine Ansammlung von Werkzeugen zur Strukturierung
und Manipulation der Daten in einer Datenbank, Funktionen, mit deren Hilfe der Datenbankbenutzer Daten eingeben, verändern, abfragen und ausgeben kann und zusätzlichen Hilfsmittel
zur Sicherung, Wiederherstellung und Schützen von Daten.
Die Kommunikationsschnittstelle erlaubt den Benützern auf verschiedene Weise, z. B. über das
Internet, mit dem Datenbanksystem zu kommunizieren.
Datenbanksysteme können umfangreiche Datenmengen, die logisch und oft auf komplexe Weise zusammenhängen, effizient verwalten.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 2
Die drei Abstraktionsebenen eines Datenbanksystems:
externe Ebene
Benutzersicht
auf Daten
Abfragen
Anwendungen
Ansicht-, Zugriff- und VerarbeitungsDefinitionen für Benutzer.
(DML – Data Manipulation Language)
Die Endbenützer können auf Daten
zugreifen, ohne sich mit der inneren
Organisation des Datenbestandes zu
befassen.
konzeptionelle Ebene
interne Ebene
Logische Datenstrukturen,
Datendefinitionen (Datenmodell)
physikalische Datenorganisation
Beschreibung der Gesamtheit aller
Daten und ihrer Beziehungen.
(DDL - Data Definition Language).
Die Trennung zwischen Datenbeschreibung und Datenmanipulation ist
wichtig, da das Datenmodell durch
den Datenbankbenutzer nicht mehr
verändert werden soll.
Datenspeicherung
Verteilung der Daten auf die
Speichermedien
1.2 Relationale Datenbanken
Ein Datenbanksystem ist nach einem bestimmtem Prinzip aufgebaut. Man unterscheidet
 Flache Datenbanken
 Relationale Datenbanken
 Objektorientierte Datenbanken
 Hybride Datenbanken.
Weithaus am häufigsten arbeitet man heute mit relationalen Datenbanken.
Anschaulich werden Relationen als Tabellen dargestellt, deren Zeilen Datensätze (records)
enthalten, die Informationsobjekte repräsentieren. Die Spalten genannt Felder (fields) repräsentieren die Eigenschaften (Attribute) dieser Objekte.
Attribute
Records
id
name
vorname
strasse
plz
ort
telefon
1
2
3
Zaug
Bauer
Meier
Martin
Barbara
Beat
Bernstrasse 5
Weststrasse 7
Neufeldstrasse 29
3000
3074
3012
Bern
Muri
Bern
031 287 34 56
031 952 45 67
031 300 49 12
Die Attribute sind fest definiert, identische Zeilen sind nicht erlaubt. Die Reihenfolge der Zeilen
bzw. Kolonnen ist grundsätzlich beliebig.
Beim Erstellen einer Tabelle muss zuerst eine Tabellenstruktur festgelegt werden: Es muss
entschieden werden, welche Felder notwendig sind (Feldnamen), von welchem Typ die Feldeinträge sind (Text, Zahlen, Datum...) und welche Länge die Felder aufweisen (Anzahl Zeichen)
Die Datensätze werden auf dem Datenträger nacheinander gespeichert. Man erwartet, dass
jeder Datensatz möglichst rasch wieder gefunden werden kann, dabei spielt die Satzlänge eine
Rolle.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 3
1. Datensatz
2. Datensatz
Name Vorname Strasse PLZ Ort Telefon ¦¦ Name Vorname Strasse PLZ Ort Telefon
Satzlänge
Für schnelles Suchen und für die Ausgabe der Daten in einer anderen Reihenfolge, wird ein Index benutzt. Beim Indizieren wird ein Feld (z.B. Name) oder eine Felderkombination (z.B. Name+Vorname) gewählt, nach welcher sortiert werden soll. Die Indexdatei enthält nur das Indexfeld in der gewählten Reihenfolge (steigend/fallend) und die Satznummern. Neue Datensätze
werden in der Indexdatei angefügt.
Bsp. Indizieren einer Datenbank nach "Name"
Name
Amsel
Bauer
Flury
Zaug
Satznummer
125
34
21
9
Index
1
2
3
4
Da die Index-Tabelle wesentlich kleiner als die gesamte Tabelle ist, kann sie viel schneller
durchsucht werden. Der Name "Flury" wird zuerst in der Index-Tabelle gesucht und anschliessend gemäss Satznummer in der Tabelle direkt adressiert.
In einer relationalen Datenbank können Daten in mehreren Tabellen gespeichert werden.
Eine Universität hat zum Beispiel verschiedene Institute. Sie beschäftigt Personen, die zu den
einzelnen Instituten gehören. Sie verfügt über Räume, von denen ein Teil den Instituten gehört,
der Rest (Hörsäle) der ganzen Universität. Sie führt Lehrveranstaltungen die durch angestellte
Personen in bestimmten Räumen durchgeführt werden und durch immatrikulierte Studierende,
besucht werden können. Sie hat ein Jahresbudget, das auf die Institute verteilt ist...
Die zugehörigen Daten könnten in einem Dateisystem gespeichert werden – in mehreren von
einander unabhängigen Dateien. Nachteile eines solches Systems sind die Datenredundanz
(die gleichen Daten werden mehrmals in verschiedenen Tabellen gespeichert), die damit verbundene Speicherplatzverschwendung und potentielle Dateninkonsistenz. Mehrbenutzerbetrieb
ist kaum möglich.
In der Tat stehen die obengenannten Daten in einer vielfältigen Beziehung miteinander.
Institute
Budget
Personal
Räume
Studierende
Lehrveranstaltungen
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 4
In einer flachen Datenbank werden Informationen über Lehrveranstaltungen und Dozenten in
einer Tabelle gespeichert:
LVNr
3184
3065
3186
2827
2828
Titel
SWS
PersNr Name
Vorname Strasse
Wohnort
eMail
Datenbanken
Duden
Einf. in Java
Algebra I
Analysis II
2
2
2
4
2
104
106
104
105
105
Nick
Werner
Nick
Urs
Urs
2500 Biel
3000 Bern
2500 Biel
3012 Bern
3012 Bern
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
Meier
Bieri
Meier
Klaus
Klaus
Dorfstr. 24
Bernstr. 20
Dorfstr. 24
Hallerstr. 5
Hallerstr. 5
Da in der Regel ein Dozent mehrere Lehrveranstaltungen anbietet, müssen seine Personaldaten mehrmals gespeichert werden (Datenredundanz).
Um redundante Daten zu vermeiden, werden die Informationen über Vorlesungen und Dozenten in zwei Tabellen gespeichert, die miteinander über den Schlüssel PersNr verknüpft sind.
Vorlesungen
Dozenten
LVNr
3184
3065
3186
2827
2828
PersNr
106
105
104
Titel
Datenbanken
Duden-Gramatik
Einf. in Java
Algebra I
Analysis II
Name
Bieri
Klaus
Meier
Vorname
Werner
Urs
Nick
SWS
2
2
2
4
2
e-Mail
[email protected]
[email protected]
meierllb.unibe.ch
PersNr
104
106
104
105
105
Strasse
Bernstr. 20
Hallerstr. 5
Dorfstr. 24
PLZ
3000
3012
2500
Ort
Bern
Bern
Biel
Eine Tabelle kann höchstens einen Primärschlüssel haben. Der Primärschlüssel muss eindeutig
sein und darf keine Nullwerte enthalten. Da für dieses Feld ein Index verwaltet wird, sollte das
Feld möglichst kompakt sein. Daher eignet sich eine Integer-Zahl besser als eine Zeichenkette
variabler Länge.
Um zwei Tabellen verknüpfen zu können, muss die zweite Tabelle einen Fremdschlüssel haben. Dieser Fremdschlüssel definiert ein Attribut, das in einer anderen Tabelle als Primärschlüssel vorkommt. Die Aufgabe des Fremdschlüssels ist auf einen Datensatz in der Detailtabelle zu verweisen. Dieser Verweis kommt durch Formulierung einer Datenbankabfrage zustande.
Über den Schlüssel PersNr wird eine Relation zwischen den Tabellen "Lehrveranstaltungen"
und "Dozenten" erstellt. Eine weitere Relation kann über den Schlüssel "Institut" erfolgen.
Lehrveranstaltungen
LVNr
Titel
SWS
PersNr
Raum
Zeit
datenbanken.docx
Dozenten
Institute
PersNr
Name
Vorname
e-Mail
Strasse
PLZ
Ort
Institut
Institut
Rektorat
Adresse
01.01.2013/ J. Arnold


Datenbanken
Seite 5
Die gesuchten Informationen können aus mehreren Tabellen zusammengestellt werden. Will
man z.B. wissen, "Welche Lehrveranstaltungen von Mitgliedern des Instituts A abgehalten werden", sind drei Tabellen an der Antwort beteiligt, Tabelle der Institute, Tabelle der Dozenten und
Tabelle der Lehrveranstaltungen. Man sucht zuerst alle Mitglieder des Instituts A (eine Hilfsmenge) und dann streicht man aus der Menge aller Lehrveranstaltungen alle, die in der Hilfsmenge nicht erhalten sind.
Der Entwurf des Datenmodells ist eine der wichtigsten Aufgaben, die der Datenbankentwickler
zu erfüllen hat. Ein Datenmodell legt fest:
 Welche Objekte (Tabellen) sollen verwendet werden?
 Welche Eigenschaften (Attribute) soll ein Objekt besitzen?
 Welche Beziehungen (Relationen) sollen verwendet werden?
Eine korrekt definierte Datenbank
 gewährleistet die Datenkonsistenz (Integrität) – in der Datenbank sind keine widersprüchlichen Daten gespeichert.
 verhindert die Datenredundanz (mehrfaches Speichern von Daten)
1.3 Anforderungen auf ein Datenbankmanagementsystem
 Datenunabhängigkeit
Logische Unabhängigkeit: die Struktur der Datenbank kann modifiziert werden, ohne dass
der Endbenutzer etwas ändern muss
Physische Datenunabhängikeit: Datenorganisation kann modifiziert werden ohne die Struktur
der Datenbank ändern zu müssen.
 Konsistenzüberwachung
Die Konsistenzüberwachung (Integritätssicherung) sorgt für die Korrektheit der Datenbankinhalte. Die Konsistenz der Daten muss auch nach Ändern, Einfügen und Löschen von Daten
erhalten bleiben. Inkonsistenzen, die dadurch vorkommen, dass z.B. eine Adresse an zwei
verschiedenen Stellen in der Datenbank gespeichert ist und bei einer Adressänderung nur
eine von beiden geändert wird, können mit einem guten Datenmodell behoben werden.
 Integration
Die Datenintegration erfordert eine einheitliche Verwaltung aller Daten, die von verschiedenen Anwendungen benötigt werden.
 Synchronisation
Konkurierende Zugriffe mehrerer Benutzer müssen synchronisiert werden, um versehentliche Schreibkonflikte auf gemeinsam benötigte Daten zu vermeiden. Typische Beispiele sind
Reservations- und Buchungssysteme. Es darf nicht vorkommen, dass zwei verschiedene
Benutzer die gleichen Plätze reservieren, auch wenn sie unmittelbar nacheinander die Anfrage starten.
 Transaktionskonzept
Ein Transaktionskonzept erlaubt die Zusammenfassung von Datenbank-Änderungen zu
Funktionseinheiten, die als Ganzes durchgeführt werden. Ein typisches Beispiel einer Transaktion ist eine Banküberweisung, die aus zwei Datenbankoperationen besteht: die Abbuchung von einem Konto und die Gutschrift des abgebuchten Betrags zum zweiten Konto.
Diese Operationsfolge muss entweder ganz oder gar nicht durchgeführt werden. Sollte zwischen den beiden Operationen ein Fehler auftreten, oder die zweite Operation nicht durchgeführt werden können, so muss auch die Wirkung der ersten Operation rückgängig gemacht
werden.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 6
 Zugriffskontrolle
Aufgabe der Zugriffskontrolle ist der Ausschluss unautorisierter Zugriffe auf die gespeicherten Daten. Dies umfasst datenschutzrechtlich geschützte Personaldaten, so wie den Schutz
firmenspezifischer Daten.
 Datensicherheit und Datenwiederherstellung
Stromausfall oder ein anderer technischer Fehler sollen zu keinem Datenverlust führen. Die
Datenbanksysteme müssen hardwaremässig gut abgesichert sein und Daten müssen durch
Recovery Mechanismen wiederherstellbar sein.
1.4 SQL
SQL (Structured Query Language) ist eine standardisierte Programmiersprache, die die Definition, Manipulation und Kontrolle der Daten in einer relationalen Datenbank ermöglicht.
SQL ermöglicht dem Datenbankentwickler, dem Datenbankadministrator und dem Datenbankbenutzer einen Zugriff auf die Datenstruktur und die Daten der Datenbank.
SQL dient auch als eine Programmschnittstelle
(API Applikation Programming Interface) zwischen einer Anwendersoftware , die auf eine Datenbank zugreift und dem Datenbanksystem.
Benutzer
Entwickler
SQL
DB
API
Administrator
SQL ist eine standardisierte Skriptsprache, die
unabhängig von einem spezifischen Datenbanksystem eingesetzt werden kann. Es gibt aber je
nach Datenbankhersteller Unterschiede im
Sprachumfang.
Man unterscheidet zwischen text-orientierten und grafisch-orientierten Datenbanksprachen.
Textorientierte Datenbanksprachen arbeiten mit einer Befehlsprache, deren Befehlsworte und
Syntax man kennen muss. In grafisch orientierten führt man eine Abfrage durch Ausfüllen eines
Formulars aus.
Textorientiert
SELECT name, vorname, strasse, plz, ort, anrede
Grafisch orientiert: Abfrageformular
Name
Vorname
Strasse
FROM stud
WHERE ort = "Bern"
PLZ
Ort
Bern
Anrede
Frau
AND anrede = "Frau"
Grafisch orientierte Datenbanksprachen sind einfacher zu gebrauchen, sie finden jedoch ihre
Grenzen bei komplizierteren Abfragen oder in Situationen, wenn mehrere Benutzer auf den
gleichen Computer zugreifen.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 7
Einige wichtige SQL-Anweisungen:
1. Queries: Suchen von Daten nach bestimmten Kriterien
SELECT * FROM person WHERE vorname = "Michael";
2. Datenmanipulation: Einfügen, Löschen und Überschreiben von Datensätzen
INSERT INTO person VALUES ("Meier", "Barbara");
//einfügen von Datensätzen
DELETE FROM person WHERE name = "Meier";
//löschen von Datensätzen
UPDATE person SET anrede = "Frau" WHERE anrede = "f" //aktualisieren von Datensätzen
3. Definition
CREATE DATABASE demo;
CREATE INDEX id ON person (name);
DROP TABLE person;
//erstellt Datenbank
//definiert index
//löscht alle Datensätze in der Tabelle
4. Operationen
EXPLAIN TABLE person;
SHOW TABLES;
//zeigt die Tabellenstruktur an
//zeigt alle Tabellen einer Datenbank
5. Kontrolle
GRANT ALL ON demo TO "username" IDENTIFIED BY "password";
//Zugriffsrechte definieren
REVOKE .....
//Zugriffsrechte aufheben
Weitere SQL Befehle mit konkreten Beispiele finden Sie im Kapitel 5 MySQL.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 8
2. MS Access
2.1 Elemente eines Access-Datenbanksystems
MS-Access ist ein Datenbanksystem, das über eine moderne Benutzeroberfläche verfügt, mit
der man graphisch Anfragen, Modifikationen, Masken und Berichte erstellen kann. Die
graphischen Operationen werden auf eine SQL-Variante abgebildet, die leider nicht dem SQLStandard genügt. Das Access-Datenbanksystem enthält folgende Elemente:
 Tabellen:
dienen zum Speichern der Daten in tabellarischer Form
 Abfragen: dienen zum Abrufen die Daten aus Tabellen nach verschiedenen Suchkriterien,
bieten die Möglichkeit, Daten aus miteinander verknüpften Tabellen anzuzeigen.
 Formulare: Datenmasken, die zur Erfassung und Anzeige der Daten und Abfragen
verwendet werden.
 Berichte:
Ermöglichen einen formatierten Ausdruck der Daten aus den Tabellen und
Abfragen.
 Makros:
Dienen zur Automatisierung von Arbeitsabläufen - eine Auflistung von Befehlen,
die von Access automatisch abgearbeitet werden.
Die mit Access erfassten Daten lassen sich einfach in andere Office Anwendungen einbinden,
und umgekehrt lassen sich Daten aus Excel-Tabellen in Access importieren.
Access ist ein typisches Datenbanksystem, das lokal als Einbenutzer – Anwendung verwendet
wird. Falls mehrere Benutzer auf die gleichen Daten zugreifen, wird es problematisch.
Neue Datenbank erstellen
 Access starten
 Leere Datenbank wählen
 Speichern Sie die leere Datenbank z.B. als
studPHB.accdb in ihrem Arbeitsverzeichnis.
Unter diesem Dateinamen werden dann alle Bestandteile dieses Datenbanksystems gespeichert
(Tabellen, Abfragen, Berichte, Formulare)
2.2 Tabellenstruktur festlegen
 Wählen Sie unter dem Ribbon „Erstellen“, Bereich
Tabelle und rechts Entwurfsansicht
 Definieren Sie folgende Felder:
- Id: Typ AutoWert, ohne Duplikate, Primärschlüssel
- Name: Typ Text, Feldgrösse 25, indiziert
- Vorname: Typ Text, Feldgrösse 25
- Strasse: Typ Text, Feldgrösse 30
- PLZ: Typ Text, Feldgrösse 4
- Ort: Typ Text, Feldgrösse 25
- Telefon: Typ Text, Feldgrösse 15
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
-
Seite 9
eMail: Typ Text, Feldgrösse 30
GebDat: Typ Datum
Fach1: Typ Text, Feldgrösse 20
Fach2: Typ Text, Feldgrösse 20
Fach3: Typ Text, Feldgrösse 20
Anrede: Typ Text, Feldgrösse 4
 Speichern Sie die Tabelle
2.3 Verschiedene Ansichten
Sie können die Tabelle in zwei Ansichten betrachten:
 Entwurfsansicht (Tabellenstruktur festlegen und aktualisieren)
 Datenblattansicht (Datensätze hinzufügen, aktualisieren, löschen)
Hinzufügen und Speichern von Datensätzen
Öffnen Sie die Tabelle in der Datenblattansicht und geben Sie einige Datensätze ein. Benützen
Sie die Tabulatortaste um von Feld zu Feld zu springen. Access speichert die eingegebenen
Daten automatisch beim Wechsel zu einem anderen Datensatz.
2.4 Formular erstellen
Wählen Sie Ribbon Erstellen und aktivieren Sie unter Weitere Formulare den Formularassistenten.
 Fügen Sie die Formular-Felder hinzu
 Fügen Sie den Titel einzufügen
 Klicken Sie auf Fertig stellen
 In der Formularansicht können Sie einige
weitere Datensätze ein eingeben
 Wechseln Sie zur Entwurfsansicht, um
(falls nötig) die Position und Grösse der
Felder zu ändern
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 10
Formulare mit Schaltflächen
Schaltfläche "Neu erfassen"
zum Einfügen von Datensätzen:
 Erstellen Sie eine neue
Schaltfläche
 Wählen Sie Datensatzoperationen – Neuen Datensatz
einfügen
 Wählen Sie die Beschriftung
als Text „Datensatz Einfügen“ Testen Sie die Schaltfläche in der Formularansicht
 Erstellen Sie weitere Schaltflächen "Datensatz drucken"
und "Datensatz löschen"
Kombinationsfelder
Die Kombinationsfelder können z.B. zum
schnellen Suchen von Datensätzen dienen.
 Wählen Sie in der Toolbox Kombinationsfeld
 Aktivieren Sie die Auswahl
Einen Datensatz im Formular,
basierend auf dem im Kombinationsfeld gewählten Wert suchen
 Wählen Sie das Feld Name in der
Felderliste
 Beschriftung: "Name suchen"
 In der Formularansicht erscheint eine Auswahlbox, in er nach Name gesucht werden kann
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 11
2.5 Import und Export von Daten
Importieren von Daten aus einer Excel-Tabelle
Damit Sie im nächsten Abschnitt die Suchfunktionen
mit mehreren Daten testen können, ergänzen Sie Ihre
Tabelle mit weiteren Datensätzen aus der Datei "adressen.xls".
Die Access- und die Excel-Tabelle müssen die gleichen Spalten haben.
 Wählen Sie unter „Externe Daten“ Excel
 Wählen Sie die Excel Datei adressen.xls
 Wählen Sie die Option Erste
Zeile enthält Überschriften
 Fügen Sie die Datensätze in
die bestehende Tabelle Tabelle1, die nur wenige Datensätze enthält
Exportieren einer Access-Tabelle in Excel:
 Öffnen Sie Ihre Access-Datei und Markieren Sie
die zu exportierende Tabelle
 Wählen Sie Datei-Exportieren und beim Dateityp
Microsoft Excel (*.xls).
2.6 Suchen
Suchen in einem Feld:
 Aktivieren Sie das Feld in dem gesucht werden soll z.B.
Name
 Register Start Klick auf Suchen (Feldstecher)
 Geben Sie den gesuchten Namen an
 Klicken Sie auf weitersuchen
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 12
2.7 Abfragen
Abfrage in der Entwurfsansicht erstellen
 Wählen Sie im Register „Erstellen“ „Abfragenentwurf“
 Wählen Sie Tabelle1
Sie möchten z.B. Namen und Vornamen aller
Frauen anzeigen
Ziehen Sie die Felder Name,
Vorname und Anrede nach
unten:
 Im Feld Anrede das AuswahlKriterium "f" eingeben. Anrede
muss nicht angezeigt werden
 Die Felder Name und Vorname aufsteigend sortieren
 Abfrage speichern und mit
Doppelklick auf Abfragenamen oder mit Klick auf „Ausführen“ die gesuchten Daten anzeigen.
Abfrage in SQL-Ansicht
Klicken Sie mit der rechten Maustaste auf
Sortierung und wählen Sie SQL-Ansicht.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 13
Abfragen mit Parametern
Im nächsten Schritt wird per Eingabe bestimmen, ob Frauen oder Männer angezeigt werden
sollen.
 Öffnen Sie erneut die letzte Abfrage in der Entwurfsansicht und geben
Sie beim Kriterium
[Anrede eingeben]
Beim Öffnen der Abfrage erscheint jetzt eine Dialogbox, in
der ein m oder f eingegeben werden kann:
Die Suchbegriffe mit oder verbinden
Sie möchten alle Studierenden anzeigen, die das Studienfach Informatik belegen.
Die zugehörige Abfrage wird wie folgt definiert:
Als Ergebnis erscheinen alle Studierenden, die im ersten, zweiten oder dritten Fach Informatik
belegen.
Verbinden der Suchbegriffe mit und
Sie suchen alle Frauen, die nicht älter als 30 sind. Die Suchkriterien werden in der gleichen
Zeile eingegeben. Bei Datum: >#01.01.1980#.
Und und oder lassen sich
kombinieren, im Folgenden
werden Studierende gesucht,
die Mathematik und Informatik belegen.
Die SQLAnsicht:
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 14
Weitere Suchausdrücke
> „Blum“
wie „M??er“
wie „*fach“
sucht alle Namen die alphabetisch nach Blum folgen.
sucht Meier, Maier, Mayer usw.
sucht Postfach, 4fach usw.
Suchaufträge:
1) Suchen Sie alle Frauen, die in Ittigen wohnen
2) Wie viele „Monika“ hat es in dieser Datei?
3) Sortieren Sie die Tabelle nach Geburtsdatum
4) Suchen Sie alle, die Studienfächer Deutsch und Englisch belegen
2.8 Aktualisierungs- und Anfügeabfrage
Die Aktualisierungsabfragen werden benutzt, um Tabellenwerte systematisch durch andere
Werte zu ersetzen. Estellen Sie eine Aktualisierungsabfrage, die die Anrede für alle f durch
Frau und für alle m durch Herr ersetzt.
 Erstellen Sie eine neue Abfrage in Entwurfsansicht und wählen Sie das Feld Anrede.
 Klicken Sie mit der rechten Maustaste auf Sortieren und wählen Sie Abfragetyp –
Aktualisierungsabfrage.
Diese Eingabe ersetzt alle f durch Frau.
Analog kann eine Löschabfrage erstellt werden, die alle Datensätze mit einer bestimmten Bedingung löscht.
Die Anfügeabfragen werden benutzt, um Datensätze aus einer zweiten Datenbank hinzufügen.
 Die aktuelle Datenbank öffnen
 Die anzufügende Datenbank mit Datei – Externe Daten –Importieren (z.B. adressen.mdb) importieren. Importiert wird dabei die Tabelle Adressen.
 Abfrage – neu – Entwurfsansicht
 Die Tabelle Adressen hinzufügen und alle Felder nach
unten ziehen.
 Mit der rechten Maustaste an Sortieren klicken und in
der Dialogbox "Abfragetyp" "Anfügeabfrage" wählen.
 Tabelle, in die eingefügt werden soll auswählen
 Abfrage speichern und ausführen
Achtung: Das Feld id macht beim hinzufügen von Daten in der Regel Schwierigkeiten. Eine mögliche Lösung: Vor dem Einfügen der Daten in beiden Tabellen das Feld ID löschen. Nach dem die
Datensätze erfolgreich eingefügt wurden, die neue Tabelle sortieren und ein neues Feld id vom
Typ Autowert erstellen. Die Datensätze werden erneut automatisch nummeriert.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 15
2.9 Arbeit mit verknüpften Tabellen
Erstellen Sie in derselben Datenbank eine neue Tabelle "buch" mit den Feldern:
 BuchID
 Autor
 Titel
 Verlag
 Preis
und geben Sie einige Datensätze ein.
(Sie können eine solche Tabelle aus S:/....../buch.mdb importieren).
Ergänzen Sie die Tabelle studPHB mit dem Feld BuchID und geben Sie einige BuchID's ein.
Abfrage mit verknüpften Tabellen
 Erstellen Sie eine neue Abfrage und fügen Sie beide Tabellen ein. Die Verknüpfung wird automatisch erstellt.
 Sie möchten sehen, welche Bücher Informatikstudierenden ausgeliehen haben und definieren eine entsprechende Abfrage.
 Speichern Sie die Abfrage und führen sie aus
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 16
2.10 Bericht erstellen
Eine formatierte Liste erstellen
Mit Hilfe der Berichte können Daten formatiert angezeigt oder ausgedruckt werden. Als Grundlage für einen Bericht kann die ganze Tabelle oder eine Abfrage,
die nur einen Teil der Daten herausfiltriert.
 Wählen Sie Im Register Erstellen Bericht - Assistent
 Wählen Sie, aus welcher Tabelle oder
Abfrage der Bericht erstellt werden soll.
Sie sollen z.B. eine Adressliste mit
Strasse, Wohnort und Telefon aus der
Tabelle1 erstellen.
 Wählen Sie die Felder aus.
 Wählen Sie die die
Sortierung
 Nach dem Fertigstellen erscheint eine Liste
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 17
Der BerichtsAssistent eignet sich sehr gut für ein schnelles Erstellen von Standardberichten.
Falls im Bezug auf Formatierung höhere Ansprüche gestellt werden, empfiehlt sich es, den
Bericht im Entwurfmodus zu entwicklung. Auf diese Art können alle individuellen
Formatierungen vorgenommen werden.
 Wählen Sie Im Register Erstellen Berichtentwurf
 Gestalten Sie mit Hilfe von Text- und Bezeichnungsfeldern ihre Datenliste. Bezeichnungsfelder werden für den Titel und Spaltenüberschrifte verwendet, die Daten erscheinen in Textfeldern.
 Die Felder können mit "&" verbunden werden. Beim Feld „Name“ muss der Tabellenname
voranstehen, da Name allein ein reserviertes Wort ist.
 Die Zeilen des Berichts können
fortlaufend numeriert werden:
Erstellen Sie ein neues Textfeld
und schreiben Sie
" =1 " hinein.
Aktivieren Sie das Feld mit der rechten
Maustaste und wählen Sie Eigenschaften.
Im Register Daten muss bei Laufender
Summe "Über Alles" stehen.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 18
Adressetiketten
 Wählen Sie „Erstellen“ – „ Etiketten“
 Wählen Sie das Etikettenformat, z.B.
Zweckform 3652.
 Klicken Sie auf „Weiter“ und wählen
Sie die Schriftart und Schriftgrösse
 Positionieren Sie die Felder auf
dem Etikettenentwurf und bestimmen Sie die Sortierfolge
 Falls beim "Fertigstellen" Probleme auftreten, schalten
Sie den Entwurfmodus ein. Feldnamebezeichnung
"Name" macht häufig Schwierigkeiten. Sie müssen in
diesem Fall [Tabelle1.Name] schreiben. Die Funktion
"Glätten()" entfernt alle Leerzeichen aus einem Feld.
Die Breite der Etiketten
kann bei bedarf im Entwurfmodus angepasst
werden. Das Ergebnis
sollte etwas so aussehen.
2.11 Startformular
Ziel ist ein benutzerfreundliches
Startformular, das es ermöglicht, alle
Datenbankoperationen mit einem
Mausklick zu starten.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 19
 Erstellen Sie ein neues Formular in Entwurfsansicht
 Benutzen Sie die Toolbox, um Texte und Buttons zu erstellen.
 Beim Erstellen einer Schaltfläche wird automatisch der Schaltflächenassistent gestartet.
 Wählen Sie Formularoperationen – Formular öffnen
 Befolgen Sie den Assistenten und testen Sie das Formular in der Formularansicht.
Öffnen einer Tabelle muss mit einem Makro gestartet werden:
 Erstellen Sie eine neue Schaltfläche "Datentabelle öffnen"
 Klicken Sie mit der rechten Maustaste und wählen Sie Eigenschaften
 Im Register Ereignis – Beim Klicken wählen – Makro Generator – Aktion Öffnen Tabelle
 Tabellen-Name eingeben und Speichern
Das Formular soll beim Öffnen der Datenbank automatisch gestartet werden:
 Wählen Sie den Startbutton und dort Access-Optionen
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 20
 Gehen sie in den Abschnitt „Aktuelle Datenbank“. Wählen Sie im Feld „Formular anzeigen“
den Name des Startformulars aus.
 Achtung: wenn Sie alle Menü- und Symbolleisten im Startformular abwählen, kann das Formular und weitere Datenbankelemente nicht mehr bearbeitet werden
2.12 Dateianlagen (z.B. Fotos) in einer Access-Datenbank speichern
 Im Tabellenentwurf wird ein Feld
hinzugefügt und benannt (z.B. „PortraitFoto“). Der Felddatentyp wird
auf „Anlage“ gestellt.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 21
 In der Entwurfsansicht des gewünschten Formulars wird das Feld
„PortraitFoto“ angewählt, ins Formular gezogen und allenfalls formatiert.
 In der Formularansicht erscheint beim Klicken auf das neu erstellte Feld oberhalb das Anlagemenu. Mit der Büroklammer (oder mit Doppelklick aufs Feld) können Dateianlagen hinzugefügt werden, mit den Pfeiltasten wird zwischen der Anzeige der verschiedenen Anlagen
(z.B. mehrere Fotos) weitergeschaltet.
2.13 Zugriffskontrolle
Access bietet verschiedene Möglichkeiten, Zugriff auf die Datenbank mit einem Passwort zu
schützen. Unter dem Ribbon „Datenbanktools“ kann man im Bereich „Datenbanktools“ die Datenbak verschlüsseln und im Bereich „Verwalten“ mit dem Button „Benutzer und Berechtigungen“ die Benutzer- und Gruppenberechtigungen und Benutzer- und Gruppenkonten definieren.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 22
3. MySQL
3.1 Was ist MySQL ?
MySQL ist ein vollwertiges Datenbanksystem, das auf der Grundlage von SQL, der strukturierten Abfragesprache für Datenbanken, aufgebaut ist. MySQL arbeitet mit einer Client-ServerArchitektur, d.h. ein zentraler Datenbankserver verwaltet Daten, auf die mit einem beliebigen
Datenbankclientprogramm zugegriffen werden kann. MySQL kann kostenfrei über das Internet
bezogen und auf den meisten Plattformen installiert werden.
MySQL eignet sich zur Verwaltung von "kleineren" Datenbeständen. Für die Verwaltung von einigen 100'000 oder Millionen Datensätzen ist der Einsatz von kommerziellen Datenbanksystemen wie ORACLE, SYBASE oder DB2 (neu UDB) angeraten.
Eine MySQL-Datenbank umfasst eine oder mehrere Tabellen, die zu einem bestimmten Projekt
gehören. Die Tabellen der Datenbank müssen einen eindeutigen Tabellennamen besitzen. Die
Tabellenspalten (colums) haben ebenfalls einen eindeutigen Namen (attribut) und einen vordefinierten Datentyp. Die Tabellenzeilen (rows) entsprechen einem einzelnen Datensatz (record)
und beinhalten in ihren Feldern die gespeicherten Informationen. Das DBMS kann die Reihenfolge der Zeilen beliebig verwalten.
3.2 MySQL Datentypen
Die erlaubten Datentypen sind nicht vollständig standardisiert und müssen daher aus der Dokumentation des verwendeten DBMS entnommen werden. Die wichtigsten Datentypen sind in
der Tabelle zusammengestellt.
SQL Typ
CHAR(M)
VARCHAR
TEXT
INTEGER
DOUBLE (M,D)
FLOAT
DATE
TIME
DATETIME
TIMESTAMP
YEAR
Beschreibung
Zeichenkette (feste Länge M) M <= 255
Zeichenkette mit variablen Länge (M <= 255)
Zeichenkette maximal 65535 Zeichen
Ganzzahl
Fliesskomma mit Doppelten Genauigkeit
Fliesskommazahl, steht wegen ODBC zur Verfügung
Datum in der Form 2004-12-31
Zeit in der Form 23:30:45
Datum + Zeit in Form 2004-12-31 23:30:45
Unix Time: Anzahl Sekunden seit 1.1.1979
Jahreszahlen in 4-Stelligen Schreiweise
3.3 Die wichtigsten Befehle
Für die Datenbankverwaltung und die Datenmanipulation verwendet man die leicht zu erlernende Scriptsprache SQL. Die wichtigsten Befehle sind in der untenstehenden Tabelle zusammengestellt (einige der Befehle sind spezifisch für die Datenbank MySQL). Angaben über die
genaue Syntax findet man leicht im Internet mit einer Suchmaschine (sql tutorial).
Befehl
INSERT
DELETE
UPDATE
SELECT
CREATE
datenbanken.docx
Beschreibung
Einfügen eines neuen Datensatzes
Löschen eines Datensatzes
Ändern eines bestehenden Datensatzes
Abfragen von Datenbankinformationen auf Grund einer Bedingung
Erzeugen einer neuen Tabelle oder einer neuen Datenbank
01.01.2013/ J. Arnold
Datenbanken
DROP
ALTER
GRANT
USE (*)
SHOW DATABASES (*)
SHOW TABLES (*)
EXPLAIN (*)
QUIT
Seite 23
Löschen einer Tabelle oder einer Datenbank
Ändern des Formats einer Tabelle
Zugriffsrechte auf Datenbanken und Tabellen setzen/ändern
Wählen der Datenbank
Anzeige der Datenbanken
Anzeige der Tabellen in der gewählten Datenbank
Anzeige der Attribute einer Tabelle
MySQL beenden
MySQL Syntax
 Jede Anweisung wird mit einem Semikolon ; abgeschlossen
 Eine Anweisung kann in mehreren Zeilen eingegeben werden
 Gross-/Kleinschreibung ist je nach Eingabe unterschiedlich:
Schüsselwörter
Gross-/Kleinschreibung wird nicht berücksichtigt
Um bessere Übersicht zu erhalten werden die Schlüsselwörter
im Script gross geschrieben.
Datenbank-/ Tabellennamen Bei UNIX berücksichtigt , bei Windows nicht berücksichtigt
Spaltennamen
Gross-/Kleinschreibung wird nicht berücksichtigt
Alias-Namen
Gross-/Kleinschreibung wird berücksichtigt
Es empfiehlt sich die Bezeichnungen immer gleich zu schreiben, im Skript werden alle
selbstdefinierte Namen, sowie Variablen-Namen klein geschrieben.
 Zeichenketten werden in "Komma" geschrieben.
3.4 Eine Tabelle mit einer Scriptdatei definieren
Man kann mit einem Texteditor eine Textdatei schreiben und als person.sql in einem
beliebigen Verzeichnis z.B. d:\scratch speichern. Mit Ausführung dieser Skriptdatei wird jeweils die alte Tabelle gelöscht und eine neue erstellt.
DROP TABLE buch;CREATE TABLE person (
id INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY,
name CHAR(25),
vorname CHAR(25),
anrede CHAR(4));
INSERT INTO person(name, vorname, anrede)
VALUES("Zaug", "Werner", "Herr");
INSERT INTO person(name, vorname, anrede)
VALUES("Bauer", "Hans", "Herr");
INSERT INTO person(name, vorname, anrede)
VALUES("Meier", "Luka", "Frau");
1. Database öffnen
mysql>use sdb2;
2. Skriptdatei ausführen mit
mysql>\. d:\scratch\person.sql
datenbanken.docx
(Leerschlag nach \. beachten!)
01.01.2013/ J. Arnold
Datenbanken
Seite 24
3.5 phpMyAdmin
Client
PhpMyAdmin ist ein gratis-Tool zur Administration von MySQL-Datenbanken. Die
Bedienung erfolgt über einen Browser.
Browser
Datenbankserver
http
Ist phpMyAdmin auf dem Webserver installiert, braucht er auf dem Computer des Benutzers nicht mehr installiert zu werden.
phpMyAdmin
DBMS
MySQL
Daten
Verbindung zur MySQL-Database erstellen
Auf unserem Webserver kann phpMyAdmin mit folgendem
Link gestartet werden:
Nach der Anmeldung mit Ihrem Benutzername und Ihrem
Password können Sie auf Ihre Database zugreifen, neueTabellen anlegen und bestehende Tabellen bearbeiten.
Database öffnen
Sie brauchen keine neue
Datenbank anzulegen, sondern Sie müssen Ihre bereits bestehende Database
öffnen. Klicken Sie links auf
den Database-Name.
Neue Tabelle erstellen
Geben Sie den Tabellenname und die Anzahl der Felder an.
Definieren Sie die Felder.
Auto_increment beim id
bedeutet, dass die
Nummer fortlaufend,
automatisch eingetragen wird.
FLOAT
Speichern
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 25
Die Tabellenstruktur wird angezeigt.
Korrekturen werden gemacht, in dem
man das entsprechende Feld markiert
und auf das Bleistift-Symbol klickt.
Zur Eingabemaske für die Dateneingabe kommt man mit Einfügen.
Daten einfügen
Alle Datensätze können mit Anzeigen
angezeigt werden.
Weiter Funktionen sind in der Menüleiste ersichtlich:
Leeren: alle Datenseätze in der geöffneten Tabelle werden gelöscht
Löschen: die aktuelle Tabelle wird gelöscht
Exportieren: Die Daten können z.B. in eine Excel-Tabelle exportiert werden.
SQL – Befehl eingeben
phpMyAdmin erlaubt es SQL-Befehle einzugeben. Will man z.B. n der ganzen Tabelle
alle leere Felder in der Spalte jahr du 2008
ersetzen, klickt man auf SQL und gibt die
Anweisung an:
UPDATE buch SET jahr = "2008"
WHERE jahr IS NULL
Daten exportieren (sichern)
Mit Exportieren kann auf eine einfache Art ein Backup der Tabellen Daten erstellt werden. Wird
die Tabelle als SQL exportiert (und gesendet) entsteht auf dem lokalne Rechner eine vollständige Kopier der Tabelle inklusiver der Feld-definitionen.
Export im csv-Format erlaubt es, die Daten für Excel zu exportieren.
Daten importieren
Eine sql-Datei wird unter SQL importiert. Anstelle vom SQL-Befehl wird eine Datei gewählt.
Eine Excel-Tabelle importieren:
Die Excel-Datei mit speichern unter als csv (Trennzeichen-getrennt) speichern.
Im phpMyAdmin ganz unten auf dem Bildschirm Textdatei
in Tabelle einfügen wählen.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 26
4. Client-Server-Architektur
Verschiedene Client-Server-Architekturen:
4.1 File-Server Architektur (intelligenter Client / "dummer" Server)
Der Server dient lediglich als grosser Festplattenspeicher mit der Möglichkeit, Dateien gemeinsam zu nutzen. Die Applikationen werden ausschliesslich auf dem Client ausgeführt.
(PC-Datenbanken, die netzwerkfähig sind, z.B. Microsoft Access).
Client
Server
DBMS
(MSAccess)
Dateien
Vorteile:
 der Umgang mit der Datenbank ist nicht viel anspruchsvoller als mit einer EinzelplatzDatenbank
 die Rechenleistung wird auf der Client-Seite erbracht
Nachteile:
 Die Dateien auf dem File-Server sind anfällig für Modifikationen durch "fremde" Benutzer mit
"fremden" Tools und können so leicht korrupt werden.
 Bei einem Serverabsturz werden offene Server-Datenbankdateien möglicherweise korrupt.
4.2 Intelligenter Client/Intelligenter Server
Auf der Clientseite verwendet man meist Java-Applikationen mit gewissen Standards z.B. JDBC
(Java DataBase Connectivity), die Abfragesprache ist üblicherweise SQL. Die Verbindung zur
entfernten Datenbanken erfolgt über das TCP/IP Protokoll. Dabei sendet der Client einen SQLBefehl (SQL statement) an das DBMS. Die Daten werden in Form eines Result-Sets (result set)
zurückgeliefert.
Datenbankserver
Client 1
JDBC, Java
Client 2
JDBC, Java
Statements 
DBMS
 Result sets
Daten
Client 2
JDBC, Java
Vorteile:
 kurze Antwortzeiten, da die Rechenleistung auf den Server und Clienst verteilt ist
Nachteile:
 grosser Wartungsaufwand auf der Clientseite
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 27
4.3 Webdatenbanken (Browser auf Client/ intelligenter Server)
Webserver, Datenbankserver
Client 1
Browser
Client 2
Browser
Client 2
Browser
Webserver mit Plugins
(Tomcat, PHP)
DBMS (MySQL)
Java, JDBC
Die erforderliche Sortware wird auf dem Server installiert. Auf dem Client muss nur der Browser
installiert sein.
Vorteile:
 grosse Sicherheit gegen Fehlermanipulation auf der Clientseite
 kein Wartungsaufwand auf der Clientseite
 neue Applikationen stehen sofort allen zur Verfügung
Nachteile:
 ev. lange Antwortzeiten, da die gesamte Rechenleistung auf dem Server ist
4.4. MS-Access als Datenbank-Client, ODBC
Die Verwendung des kommandozeilenbasierten Monitorprogramms MySQL ist gewöhnungsbedürftig, aber für die Untersuchung der Datenbank bei auftretenden Problemen sehr nützlich.
Vielfach zieht man aber heutzutage einen Client mit einer grafischen Benützeroberfläche vor.
Mit wenig Aufwand kann man MS-Access als Client einsetzen. Damit lassen sich auch benützerfreundliche Access-Frontends schreiben, die auf eine MySQL- statt auf eine AccessDatenbank zugreifen. Die Verbindung zwischen Access und der MySQL-Datenbank wird durch
eine standardisierte Schnittstelle ODBC (Open DataBase Connectivity) hergestellt, die zwar
nicht sehr leistungsfähig ist, aber heutzutage für den Datenaustausch zwischen verschiedenen
Datenbankprodukten intensiv genützt wird.
Die Einrichtung der ODBC-Schnittstelle erfordert zwei Schritte. Zuerst wird der ODBC-Treiber
für MySQL installiert, den man von der MySQL Website unter dem Namen Connector/ODBC
bezieht (MyODBC-3.51.06.exe). Der Treiber wird mit Doppelklick auf diese exe-Datei installiert.
Als nächstes wird eine ODBC-Datenquelle eingerichtet, welche diesen Treiber verwendet.
Wählen Sie Systemsteuerung Verwaltung –Datenquelle (ODBC)
 Register System-DNS
 Hinzufügen
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 28
Man wählt einen neuen Benützer-Datenquellennamen mit
dem eben installierten MySQL ODBC-Treiber. Unter Konfiguration müssen insbesondere IP-Adresse des Servers,
Database-Name, User und Password ausgefüllt werden.
Data Source Name: sdbxx
Host/Server Name: clab1.phbern.ch
Database Name: sdbxx
User: username
Password: *******
Jetzt sind Sie in der Lage, von MS-Access aus auf die Datenbank demo1 zuzugreifen. Dazu
starten wir MS-Access und wählen im Datei-Menü-Öffnen den Dateityp ODBC-Databases. Auf
dem Registerblatt Computerdatenquelle wählen Sie demo1 und nachfolgend die Tabelle person. Diese wird in der üblichen Tabellenform dargestellt und kann weiter bearbeitet werden. Die
Änderungen werden unmittelbar in der MySQL-Datenbank übernommen.
Achtung: Falls das Feld id in MySQL als auto_increment eingestellt wurde, macht das Einfügen
von neuen Datensätzen Schwierigkeiten (Fehlermeldung beim Speichern), es ist daher besser
das automatische Einfügen von id abzuschalten.
 Wählen Sie im Access
Datei öffnen
 Wählen Sie unter Datentyp
ODBC Database
 Suchen Sie im Register
Computerdatenquelle
Die Datenbank demo1
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 29
 Markieren Sie die Tabelle
person
Die Datensätze erscheinen in
Tabellen-Ansicht und können
mit Access beliebig bearbeitet
werden.
4.5. Client-Datenbankapplikationen mit JDBC
Java Database Connectivity (JDBC) ermöglicht es mit Java auf relationale Datenbanken zuzugreifen. Man benötigt dazu einen JDBC-Treiber als Bindeglied zwischen der Java-Applikation
und der Datenbank. Für MySQL gibt es einen kostenlosen JDBC-Treiber, der vom Internet
(Suchmaschine mit Stichworten mysql jdbc) heruntergeladen werden kann.
Die jar-Datei (mysql-connector-java-3.0.8-stable-bin.jar) kopiert man in das Verzeichnis
jre/lib/ext der verwendeten JVM.
Damit das Java-Programm auf die Datenbank zugreifen kann, muss zuerst mit
Class.forName() die Klasse des JDBC-Treibers geladen und mit DriverManager.getConnection() eine Verbindung zur Datenbank auf dem Datenbank-Server erstellt
werden. Nachher besitzen wir (innerhalb der vergebenen Zugriffsrechte) Zugang zu allen Tabellen dieser Datenbank und können diese mit SQL-Befehlen bearbeiten. Dies geht zweistufig: zuerst muss mit createStatement() der Befehl vorbereitet und dann für SELECT-Befehle mit
executeQuery() ausgeführt werden. (Für INSERT, UPDATE oder DELETE und für das Datenbankmanagement wird executeUpdate() verwendet.)
Bei der Ausführung von executeQuery() erhalten wir eine Instanz von ResultSet zurück, mit
der auf die Datensätze der Query zugegriffen werden kann. Dabei wird ein interner Zeiger, Cursor genannt, geführt, der zu Beginn vor dem ersten zurückgegebenen Datensatz steht. Mit
next() wird der Cursor auf den nächsten Datensatz geschoben und gleichzeitig ein boolean
zurückgegeben, der false wird, sobald der Cursor hinter dem letzten Datensatz steht. Man
kann deshalb mit einer einfachen while-Schleife
while (rs.next())
{
...
}
alle zurückgegebenen Datensätze durchlaufen. Die Datenbankoperationen werfen eine
SQLException aus, die man in einem try-catch-Block anfangen muss. Zudem ist es nötig, am
Schluss alle Resourcen wieder freizugeben, indem man den ResultSet, das Statement und die
Connection schliesst. Das folgende Programm schreibt Autor, Titel, Jahr und Verlag aller Datensätze der Tabelle buch in ein Console-Fenster.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 30
// DbEx1.java
import java.sql.*;
import ch.aplu.util.*;
class DbEx1 extends Console
{
DbEx1()
{
try
{
Class.forName("org.gjt.mm.mysql.Driver");
Connection con = DriverManager.getConnection(
"jdbc:mysql://kllab.unibe.ch/sdb2", "sdb2", "db2");
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM buch");
while (rs.next())
println(rs.getString("autor") + ", " +
rs.getString("titel") + ", erschienen " +
rs.getInt("jahr") + " bei " +
rs.getString("verlag"));
}
catch (Exception ex) {}
}
public static void main(String[] args)
{
new DbEx1();
}
Mankell, Vor dem Frost, erschienen 2003 bei Zsolnay
}
Hahn, Das verborgene Wort, erschienen 2002 bei DVA
Forsyth, Der Lotse, erschienen 2001 bei Piper
Eine schönere Darstellung liefert das
Beispiel DbEx2.java.
Der Programmieraufwand ist ber entsprechen grösser.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 31
5. Dynamische Webseiten
5.1 Interaktionen
Bei statischen Webseiten werden HTML-Dateien auf dem Server abgelegt und zur Darstellung
unverändert vom Webserver zum Client übertragen.
Bei dynamischen Webseiten werden die Seiteninhalte erst zur Laufzeit, d.h. beim Aufrufen der
Webseite generiert. Die Webseiten enthalten neben dem HTML-Code weitere Programmanweisungen, die auf dem Webserver ausgeführt werden. Dabei kann der Server zum Aufbau der
Seite Informationen von verschiedenen Quellen, beispielsweise einer Datenbank beziehen.
Im Gegensatz zu einer üblichen PC-Applikation, sind bei statischen Webseiten die Interaktionsmöglichkeiten stark eingeschränkt. Bei den dynamischen Webseiten lassen sich Benutzeroberflächen erzeugen, die einer üblichen Applikation entsprechen.
5.2 HTTP-Transaktionen
HTTP basiert auf einem einfachen Anforderung/Antwort-Schema. Dabei sendet der Client eine
Anfrage an den Server und dieser sendet eine Antwort zurück. Dabei ist zu beachten, dass
HTTP statuslos ist, d.h. nachdem der Server die Antworten geliefert hat, "erinnert" sich dieser
nicht mehr an die erfolgte Transaktion.
Für die Erstellung interaktiver Applikationen ist die Statuslosigkeit von http ein entscheidender
Nachteil. Das "Errinnerungsvermögen" des Web-Clients beschränkt sich gewöhnlich darauf, die
letzte gesendete Seite lokal zu speichern und mit der "Back"-Taste nochmals anzeigen und abschicken zu können.
Wenn ein Benutzer z.B. einen "Einkaufskorb" zusammenstellt, der über mehrere Webseiten
führt und möglicherweise eine Wahl rückgängig machen will, oder zusätzlich Information aus
einer anderen Webseite einholen will, sind "sessionsartige" Transaktionen notwendig.
Folgende Lösungen bieten sich an:
 Auf dem Server wird der vorhergehenden Transaktion eine Sessionsnummer zugeordnet,
welche auf der IP-Adresse des Clients beruht.
 Der Server übermittelt dem Browser gewisse Informationen der vorhergehenden Transaktion. Dies kann auf zwei Arten geschehen:
- die Information ist im zugeschickten HTML-Formular enthalten, z.B. in "Hidden" –
Elementen
- die Information wird beim Client in Form von Cookies abgelegt. Dies ist der Grund, dass datenbankorientierte Webseiten oft eine Menge von Cookies erzeugen.
5.3 Verschiedene Technologien
Zur Erzeugung von dynamischen Web-Seiten, d.h. Seiten, die erst zur Laufzeit generiert
werden, ist es nötig, dass auf dem Server zusätzlicher Code ausgeführt wird, der diese Seite
erstellt. Der Client wählt nicht eine HTML-URL, sondern eine Programmdatei, die der Server in
der Folge startet. Die Unterscheidung zwischen einer HTML-Datei und einer Programmdatei
erfolgt auf Grund der Dateiname-Erweiterung. Je nach verwendetem System, hat diese Datei
ein Erweiterung cgi, jsp, php usw.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 32
CGI (Comon Gateway Interface)
CGI ist eine Scriptsprache zur Generierung von dynamischen Webseiten, wurde bereits in der
Anfangsphase des Webs definiert. CGI ist jedoch langsam, da für jeden Request ein neuer Prozess erzeugt wird.
Servlets
Servlets sind Java-Programme, die dynamische Webseiten generieren. Servlets bieten
wesentlich bessere Performance und mehr Funktionen als CGI.
JSP Java Server Pages
JSP sind HTML-Seiten, in denen Java Code eingebettet ist. JSP-Tags definieren den JavaCode, der ausgeführt werden soll, wenn ein Benutzer über seinen Browser das JSP von einem
Webserver abruft. JSP eignet sich besonders gut, um Webapplikationen mit
Datenbankanbindungen zu programmieren.
ASP
Microsoft hat für ihren Webserver IIS (Internet Information Server) eine eigene Scriptsprache
ASP (Activ Server Pages) entwickelt. ASP's sind HTML-Seiten, die Scriptcode enthalten, in der
Regel VisualBasicScript. Nachteil von ASP: es ist nur für Windows und Microsoft IIS verfügbar.
Weil die beiden Technologier sehr ähnlich sind, die wichtigsten Unterschiede:
Eigenschaft
JSP
ASP
Platformunabhängigkeit
ja
nein
Portable Komponenten
ja
nein
Programmiersprache
java
Visual Basic
Vorkompilierung
ja
nein
PHP
PHP ist eine Scriptsprache, deren Code ähnlich wie bei JSP in HTML eingebettet ist.
Vorteil: PHP ist eine einfache Skriptsprache, die ohne Kenntnisse einer Programmiersprache
relativ leicht erlernbar ist.
Nachteil: fehlende Einheitlichkeit der Datenbank-Schnittstellen. Datenbank-Code muss explizit
für eine ganz bestimmte Datenbank geschrieben werden und ist damit an diese gebunden.
5.4 Datenbanken im Internet
Im Internet finden Sie Tausende von Webdatenbankapplikationen, die umfangreiche
Datenmengen verwalten. Die Suchmaschine Google verwaltet Informationen aus 4 Milliarden
Webseiten, es gibt grosse Geo-Datenbanken, die Informationen über alle Länder der Welt
enthalten, Literatur- und Musik-Datenbanken.
Ein immer grösserer Teil von Webseiten hat bereits eine Datenbankanbindung und wird
dynamisch erzeugt.
Beispiele hierfür sind Online-Shops, Online-Umfragen, Online-Buchungen, viele Banken bieten
Online Banking als Diensleistung an, Zahlungsverkehr und Börsetransaktionen lassen sich
bequem zuhause von einem privaten PC erledigen. Im Hintergrund dieser Dienstleistungen
laufen grosse Datenbankapplikationen.
Der Umgang mit Webdatenbanken und die Einrichtung von Webdatenbanken gehört zu den
Grundkenntnissen von Personen, die sich mit Informatik befassen.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 33
6. Java Server Pages
6.1 JSP Request
Java Server Pages (JSP) ist eine Technologie für die Programmierung von Webseiten mit dynamischen Inhalten. Sie wurde von der Firma Sun entwickelt.
JSP sind HTML-Seiten, in denen Java Code eingebettet ist. JSP-Tags definieren den JavaCode, der ausgeführt werden soll, wenn ein Benutzer über seinen Browser das JSP von einem
Webserver abruft.
Überblick über einen JSP Request:
request
Browser
JSP
Webserver
JSP- Engine
response
Servlet
1) Der Browser schickt über HTML-Code einen Request an den Webserver
2) Der Webbrowser erkennt, dass der Request JSP enthält und leitet ihn an die JSP-Engine
3) Die JSP-Engine übersetzt das JSP in ein Servlet. Die Übersetzung des JSP in ein Servlet
findet nur statt, wenn das Servlet noch nicht existiert, oder der JSP-Quellentext geändert
wurde.
4) Das erzeugte Servlet wird ausgeführt. Dabei produziert es eine Response
5) Die Response wird an den Webserver zurückgeliefert, der sie über http an den Browser
schickt.
Was brauchen Sie für JSP?
Auf dem Server:
 Java JDK
 Tomcat Server
 MySQL-Datenbank
 JDBC-Treiber für MySQL
 FTP Server
Auf dem Client:
 Editor (HomeSite, Ultradev, Dreamweaver MX)
 Browser
 FTP-Zugriff auf ein Verzeichnis auf dem Server (zum Speichern von JSP-Seiten)
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 34
6.2 Einbettung vom Java-Code in JSP-Seiten, Syntax
Für den Java-Code wird in den JSP-Seiten folgender Syntax verwendet: <% Java-Code %>
Man unterscheidet zwischen
Anweisungen:
<% Anweisungen %>
Ausdrücken:
<%= Ausdrücke %>
Die Einbettung der Ausdrücke im HTML Code:
<p> Die Summe beträgt <%= summe %></p>
Vereinbarungen: <%! Vereinbarung %>
Bei einer Variablendeklaration besteht ein Unterschied zwischen
<%! int i = 0;%> und <% int i = 0; %>
Kommentare:
<%! int i = 0;%>
definiert eine Instanzvariable, die beim
erstmaligen Laden der Seite initialisiert wird
<% int i = 0; %>
definiert eine lokale Variable, die bei jedem Laden
der Seite neu initialisiert wird.
Es gibt zwei Arten von Kommentare
<!--Beliebiger Text-->
<% // Kommentar %> oder <% /* Kommentar */ %>
HTML-Code und Java-Code lassen sich beliebig mischen:
<%
for (int i = 0; i < 5; i++)
{
%>
HTML Text
<%
}
%>
HTML-Tags könne JSP-Actionen enthalten, z.B.
<jsp:forward page = "dateiname.jsp"/>
leitet weiter auf die angegenene Seite.
<jsp:include.page = "dateiname.jsp"/>
die iclude-Datei wird zur Laufzeit aufgerufen und im
Kontext der Hauptseite ausgeführt.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 35
6.3 Eingabe und Ausgabe ohne Datenbankzugriff
Als Editor kann ein beliebiger Texteditor (z.B. HomeSite) benutzt werden. Wir verwenden den
Macromedia Dreamweaver MX, der uns erlaubt, Dateien bequem auf den Server zu kopieren.
 Neue Site erstellen
Starten Sie den Dreamweaver MX
und wählen Sie im Menü Site – Site
verwalten.
Wählen Sie Neu um eine neue Site
einzurichten.
 Sitename z.B. demo
 Servertechnologien JSP
 Lokal bearbeiten, dann auf den Server laden
 Lokalen Ordner auf ihrer Festplatte wählen
 FTP Verbindung zum Testserver
 Verbindung definieren
 Verbindung: FTP
Host:
User:.....
Password:.....
 Testverbindung prüfen
 Die Site-Definitionen können nachträglich mit Site – Site wählen – Bearbeiten geändert werden
 Neue JSP-Datei erstellen
Datei – Neu wählen oder mit der rechten Maustaste
rechts im Register Dateien klicken
 Speichern Sie die Datei z.B. als demo.jsp.
Die Seite erscheint in der Lokalen Ansicht,
im Register Dateien.
 Geben Sie den Titel ein
 Datei auf den Server kopieren:
 Markieren Sie die Datei demo.jsp
 Klicken Sie den blauen Aufwärtspfeil
Die Datei erscheint in der Remote-Ansicht
 Analog können Dateien vom Server
heruntergeladen werden
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 36
Bsp. 1: Speichern der Formularwerte in Variablen und Ausgabe der gespeicherten Werte.
<%//ex1.jsp, Einfache Eingabe und Ausgabe%>
<%
String vorname = "";
String alter = "";
String antwort = "";
%>
<%
if (request.getParameter("submit") != null)
{
vorname = request.getParameter("tVorname );
alter = request.getParameter ("tAlter");
antwort = "Ihr Name ist " + vorname + ". Sie sind " + alter + " Jahre alt.";
}
%>
<html>
<head><title>ex1</title></head>
<body bgcolor="#33CCCC">
<p> </p>
<form name="form1" method="get">
<p>Name <input type="text" name="tVorname" value="<%= vorname %>"></p>
<p>Wie alt sind sie?
<input type="text" name="tAlter" value="<%= alter %>"></p>
<p><input type="submit" name="submit" value="Abschicken"></p>
<p> <%= antwort%></p>
</form>
</body>
</html>
Speichern Sie diesen Programm-Code unter test1.jsp und
kopieren sie ihn auf den Server.
Die JSP-Seite kann jetzt mit einem Browser abgerufen
werden.
Erklärungen zum Programmcode:
String vorname = "";
String alter = "";
String antwort = "";
Variablendeklaration
if (request.getParameter("submit") != null)
Prüft, ob die Schaltfläche Abschicken
gedrückt wurde.
vorname = request.getParameter( "tVorname" );
alter = request.getParameter( "tAlter" );
Formularwerte werden in Variablen
gespeichert
<p> <%= antwort%></p>
Mit diesem Tag ist es möglich, im
HTML-Code Inhalt einer Variablen
auszugeben.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 37
Bsp. 2: Eingabefehler abfangen.
Die Eingabe wird überprüft. Falls die Eingabe leer ist, erscheint eine Fehlermeldung.
<%//ex2.jsp%>
<%
String vorname = "";
String alter = "";
String antwort = "";
String msg = "";
if (request.getParameter("submit") != null)
{
vorname = request.getParameter( "tVorname" );
if (vorname.equals(""))
msg = "Der Vorname fehlt.";
alter = request.getParameter( "tAlter" ).trim();
if (alter.equals(""))
msg = msg + " Bitte Alter eingeben.";
if (msg.equals(""))
antwort = "Ihr Name ist " + vorname + ". Sie sind " + alter + " Jahre
alt.";
}
%>
<html>
<head><title>ex2</title></head>
<body bgcolor="#33CCCC">
<p> </p>
<form name="form1" method="get">
<p>Name <input type="text" name="tVorname" value="<%= vorname%>"></p>
<p>Wie alt sind sie?<input type="text" name="tAlter" value="<%= alter%>"></p>
<p><input type="submit" name="submit" value="Abschicken"></p>
<p> <%= antwort%></p>
</form>
<p> <%= msg%></p>
</body>
</html>
Es ist oft sinnvoll die Zahleneingabe zu überprüfen, da Buchstaben anstelle von Zahlen
Programmfehler verursachen können. Unser Programm kann mit einem try – catch – Block
ergänzt werden, in dem man versucht die Eingabe in ein Integer umzuwandeln. Wenn es nicht
möglich ist, wird eine FormatNumberExeption ausgeworfen und eine Fehlermeldung
ausgegeben.
alter = request.getParameter("tAlter").trim();
int a = 0;
if (alter.equals(""))
msg = msg + " Bitte Alter eingeben.";
else
{
try
{
a = Integer.parseInt(alter);
}
catch (NumberFormatException ex)
{
msg = msg + "Die Altereingabe ist fehlerhaft.";
}
}
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 38
6.4 JSP und MySQL-Datenbanken
Um mit JSP auf eine MySQL-Datenbank auf dem Server zuzugreifen, verwendet man die Java
Database Connectivity (JDBC). Man verwendet den gleichen JDBC-Treiber, wie bei den Java-Applikationen (Kap. 4.5) als Bindeglied zwischen der Java-Applikation und der Datenbank.
Für MySQL gibt es einen kostenlosen JDBC-Treiber, der vom Internet heruntergeladen werden
kann. Der JDBC Treiber wird auf dem Webserver installiert.
Die wichtigsten JDBC-Klassen liegen im Package java.sql, das mit import java.sql *; importiert werden muss. Damit das Java-Programm auf die Datenbank zugreifen kann, muss zuerst gleich
wie bei einem Java-Programm mit Class.forName() die Klasse des JDBC-Treibers geladen
werden. Der MySQL-Treiber wird mit Class.forName("org.gjt.mm.mysql.Driver");
geladen, die Verbindung zur Datenbank auf dem Datenbank-Server wird aufgebaut mit
Connection con = DriverManager.getConnection(host, user, pasword).
Damit Sie nicht in jedem Programm neu alle Angaben für die Verbindung eingeben müssen, ist
es vorteilhaft eine Datei "connect.jsp" zu erstellen und diese in jedem Programm mit
<% include file="connect.jsp %> aufzurufen.
Die Datei "connect.jsp" ist wie folgt definiert (Sie müssen Ihre database, tabelle, user und
password eingeben, den Rest können Sie übernehmen):
<% //connect.jsp %>
<%!
String host = "xxx";
String database = "database";
String table = "table";
String username = "user";
String password = "password";
String driver = "org.gjt.mm.mysql.Driver";
String connection = "jdbc:mysql://" + host + "/" + database;
%>
Mit dieser Connection besitzen Sie den Zugang zu allen Tabellen ihrer Database und können
diese mit SQL-Befehlen bearbeiten.
Um die folgenden Beispiele testen zu können, benötigen Sie eine MySQL tabelle "person" mit
den Feldern id (integer, not null, auto_increment), name char(25) und vorname char(25). Die
Tabelle darf auch mehr Spalten haben, es werden aber nur diese angezeigt.
Im ersten Beispiel "person.jsp" wird eine Verbindung zur MySQL Datenbank auf dem Server
hergestellt, es werden alle Datensätze ausgewählt und der erste Datensatz wird angezeigt. Um
den Programmcode im Rahmen zu halten, zeigen wir in
allen folgenden Beispielen nur die zwei ersten Felder
der Tabelle person.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 39
Programmcode:
<% //person.jsp %>
<%@page language="java" import="java.sql.*" %>
<%@ include file="connect.jsp" %>
<%
Class.forName(driver);
Connection con = DriverManager.getConnection(connection,username,password);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM person");
rs.last();
int nbRecords = rs.getRow();
rs.first();
%>
<html>
<head><title>person</title></head>
<body>
<form name="form1" method="get" action="">
<p>Name:<input type="text" name="tName" value="<%=rs.getObject("name")%>">
<p>Vorname:<input name="tVorname" type="text"
value="<%=rs.getObject ("vorname")%>"></p>
</form>
<p>Anzahl Datensätze <%= nbRecords %></p>
</body>
</html>
<%
rs.close();
con.close();
%>
</p>
Erklärungen zum Programmcode:
<%@ include file="connect.jsp" %>
Class.forName(driver);
Connection con = ….
holt die Verbindungsdaten
ruft den JDBC Treiber auf
Definiert die Connection con
Statement stmt = con.createStatement();
Erzeugt ein neues Statement-Objekt. Über dieses Objekt können SELECT-Statements ausgeführt werden.
ResultSet rs = stmt.executeQuery("SELECT * FROM person");
Die Anfrage wird mit dem Befehle "executeQuery() ausgeführt.
Das Ergebnis der Anfrage wird in einem ResultSet rs gespeichert. Es enthält alle Datensätze,
die die Anfragebedingungen erfüllen.
(bei "SELECT * " alle Datensätze).
rs.last();
int nbRecords = rs.getRow();
rs.first();
Um die Anzahl der Datensätze zu bestimmen,
wird der Zeiger auf den letzten Datensatz gesetzt,
die aktuelle Datensatznummer gespeichert und
der Zeiger wieder auf den ersten Datensatz gesetzt.
rs.close();
con.close();
Am Schluss werden die Ressorcen wieder freigegeben, in dem man den Resultset und die
Verbindung schliesst.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 40
6.5 Datenbankfunktionen, modular programmiert
Die wesentlichsten Elemente einer Datenbank-Applikation sind
- Anzeigen von Datensätzen mit Navigieren
- Datensätze suchen
- Datensatz aktualisieren
- Datensatz einfügen
- Datensatz löschen
- Liste aller Datensätze anzeigen
- Zugriff auf eine Seite einschränken
Eine Applikation, die alle diese Funktionen beinhalten, ist für den Einstieg zu kompliziert.
Im Folgenden werden alle diese Funktionen in einzelnen Applikationen vorgestellt. Mit Hilfe dieser Bausteine können Sie dann selbst ihre Datenbank-Applikation, die mehrere Funktionen beinhaltet, zusammenstellen.
Module:
person.jsp
person_search.jsp
person_insert.jsp, insert.jsp
person_navig.jsp
person_update.jsp
person_search_delete.jsp
person_liste.jsp
person_login.jsp, login.jsp
ist die Ausgangdatei für jede einzelne Applikation
suchen der Datensätze nach Namen
Einfügen von Datensätzen
Navigation mit first, prev, next, last
Aktualisieren von Datensätzen
Suchen und löschen
Liste aller Datensätze
Zugriff auf eine JSP-Seite mit Anmeldung
6.5.1 Suchen von Datensätzen
Erstellen Sie eine neue Datei und im
Entwurfsmodus ein Formular nach Vorlage
rechts. Sie können auch den Code der Datei
person.jsp übernehmen und es mit einem
Textfeld "sName" und Schaltfläche "search"
ergänzen.
Der Programmcode einer Suchseite:
<% //person_search.jsp %>
<%@page language="java" import="java.sql.*" %>
<%@ include file="connect.jsp" %>
<%
String msg = "";
String sql = "";
String suchName = request.getParameter("sName");
if (suchName == null || suchName.equals(""))
{
sql = "SELECT * FROM person";
msg = " Alle Datensätze ausgewählt.";
} ...........................................................................
else
{
sql = "SELECT * FROM person WHERE name = '" + suchName + "'";
msg = "Suchen mit leerem Namen klicken, um alle Datensätze auszuwählen.";
}
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 41
Class.forName(driver);
Connection con = DriverManager.getConnection(connection,username,password);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(sql);
boolean isEmpty = !rs.next();
if (isEmpty)
{
sql = "SELECT * FROM person";
msg = " Kein Datensätze gefunden. Alle Datensätze ausgewählt";
rs = stmt.executeQuery(sql);
}
rs.last();
int nbRecords = rs.getRow();
rs.first();
%>
<html>
<head><title>person_search</title></head>
<body>
<form name="form1" method="get" action="">
<p>Name:
<input type="text" name="tName" value="<%=rs.getObject("name")%>">
</p>
<p>Vorname:
<input name="tVorname" type="text" value="<%=rs.getObject("vorname")%>">
</p>
<p>Suche nach
<input name="sName" type="text" >
<input name="search" type="submit" value="suchen"> <p><%=msg%></p>
</p>
</form>
<p>Anzahl Datensätze <%= nbRecords %></p>
</body>
</html>
<%
rs.close();
con.close();
%>
Erklärungen zum Programmcode:
Im Textfeld "sName" wird ein Suchbegriff eingegeben, das mit
String suchName = request.getParameter("sName");
geholt und in der Variablen "suchName" gespeichert wird.
Diese Aktion wird durch das Klicken der Schaltfläche "Suchen" ausgelöst. Man muss hier
verschiedene Zustände berücksichtigen:
- falls "Suchen" nicht geklickt wird, werden alle Datensätze angezeigt
- falls "Suchen" geklickt wird und Textfeld sName ausgefüllt ist, werden nur Datensätze mit
Name = suchkriterium ausgewählt.
Auch bei Spezialfällen darf das Programm nicht aussteigen:
- falls kein Suchkriterium eingegeben wurde (und Suchen trotzdem gedrückt wird – in diesem
Fall werden wieder alle Datensätzte ausgewählt
- falls kein Datensatz mit diesem Name gefunden wurde
(boolean isEmpty = !rs.next(); (rs ist leer, wenn kein nächstes Element existiert)
auch in diesem Fall werden alle Datensätze ausgewählt, mit einer passenden Rückmeldung.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 42
6.5.2 Datensatz suchen und löschen
Erstellen Sie im Entwurfmodus eine Schaltfläche "delete"
und ein verstecktes Feld "deleteId".
Programmcode
<% //person_search_delete.jsp %>
<%@page language="java" import="java.sql.*"%>
<%@ include file="connect.jsp" %>
<%
String sql = "SELECT * FROM person";
String suchName = "";
String msg = "";
int nbRecords = 0;
Class.forName(driver);
Connection con = DriverManager.getConnection(connection,username,password);
Statement stmt = con.createStatement();
// delete
if (request.getParameter("delete") != null)
{
sql = "DELETE FROM person WHERE id = '"+request.getParameter("deleteId")+"'";
stmt = con.createStatement();
stmt.executeUpdate(sql);
msg = " Datensatz wurde gelöscht";
}
// search
suchName = request.getParameter("sName");
if (suchName == null || suchName.equals( "" ))
{
sql = "select * from person";
msg = " Alle Datensätze ausgewählt";
}
else
{
sql = "SELECT * FROM person WHERE name = '" + suchName + "'";
msg = " Suchen mit leerem Namen klicken, um alle Datensätze auszuwählen.";
}
stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(sql);
//keine Datensätze gefunden
boolean isEmpty = !rs.next();
if (isEmpty)
{
stmt = con.createStatement();
rs = stmt.executeQuery( "SELECT * FROM person");
msg = " Keine Datensätze gefunden. Alle Datensätze ausgewählt";
}
//nbRecords
rs.last();
nbRecords = rs.getRow();
rs.first();
%>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 43
<html>
<head><title>person_search_delete</title></head>
<body >
<form name="form1" method="get" action="">
<p>Name:<input type="text" name="tName" value="<%=rs.getObject("name")%>"></p>
<p>Vorname:<input name="tVorname" type="text"
value="<%=rs.getObject("vorname")%>"></p>
<p>Suchen nach: <input name="sName" type="text"
value = "<%=suchName == null? "":suchName%>">
<input name="search" type="submit" value="Suchen"><%= msg %></p>
<input type="hidden" name="deleteId" value="<%=rs.getObject("id")%>">
<input name="delete" type="submit" value="Datensatz löschen">
</form>
<p>Anzahl Datensätze <%= nbRecords %></p>
</body>
</html>
<%
rs.close();
con.close();
%>
Erklärungen zum Programmcode:
Damit genau der aktuelle Datensatz gelöscht wird, definiert man ein hidden-Feld, in dem man
die id-des aktuellen Datensatzes als value ablegt.
<input type="hidden" name="deleteId" value="<%=rs.getObject("id")%>">
Mit request.getParameter("deleteId") wird dieser Parameter zurückgeholt und im delete -Statement verwendet. Die allgemeine Form einer delete-sql ist
sql = "DELETE FROM person WHERE id = 'nr'";
value = "<%=suchName == null? "":suchName%>"> im Textfeld sName bewirkt, dass das Feld leer bleibt, wenn
kein Suchbegriff eingegeben wird, sonst wird die Eingabe angezeigt.
6.5.3 Datensatz aktualisieren
Erstellen sie eine neue Datei mit den
nebenstehenden GUI-Elemente. Sie können den
Programmcode der Datei person.jsp
übernehmen und mit der Schaltfläche "update"
ergänzen.
Programmcode einer Update-Seite:
<% //person_update.jsp %>
<%@page language="java" import="java.sql.*"%>
<%@ include file="connect.jsp" %>
<%
String sql = "SELECT * FROM person";
String msg = "";
Class.forName(driver);
Connection con = DriverManager.getConnection(connection,username,password);
Statement stmt = con.createStatement();
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 44
//update
if (request.getParameter("update") != null)
{
sql = "UPDATE person SET name = '"+request.getParameter("tName") +
"',vorname = '" + request.getParameter("tVorname") + "' WHERE id = '" + request.getParameter("updateId") + "'";
stmt.executeUpdate(sql);
msg = "Datensatz wurde aktualisiert";
}
sql = "SELECT * FROM person";
ResultSet rs = stmt.executeQuery(sql);
rs.last();
int nbRecords = rs.getRow();
rs.first();
%>
<html>
<head><title>person_update</title></head>
<body bgcolor="#33CCCC">
<form name="form1" method="get" >
<p>Name:
<input type="text" name="tName" value="<%=rs.getObject("name")%>"></p>
<p>Vorname:
<input name="tVorname" type="text" value="<%=rs.getObject("vorname")%>">
</p>
<p>
<input type="hidden" name="updateId" value="<%=rs.getObject("id")%>">
<input name="update" type="submit" value="Aktualisieren"></p>
</form>
<p>Anzahl Datensätze <%= nbRecords %></p>
<p><%= msg %></p>
</body>
</html>
<%
rs.close();
con.close();
%>
Erläuterungen zum Programmcode:
In der Regel wird nicht nur der erste, sondern der aktueller Datensatz nach Suchen aktua-lisiert.
Damit man genau weiss, welcher Datensatz zu aktualisieren ist, erstellt man im HTML-Teil ein
hidden-Feld "updateID", in dem die "id" des aktuellen Datensatzes "angezeigt" wird.
<input type="hidden" name="updateId" value="<%=rs.getObject("id")%>">
Mit request.getParameter("updateId") wird dieser Parameter zurückgeholt und im Update-Statement verwendet.
Die allgemeine Form eines Update-Statements ist:
UPDATE person SET name = "nn", vorname = "vv" WHERE id = "nr";
In unserem Beispiel werden anstelle von nn, vv und nr die aktuellen Werte der Textfelder
tName, tVorname und updateID zurückgeholt.
Schreiben Sie eine Applikation, die Suchen und Aktualisieren kann.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 45
6.5.4 Datensatz einfügen
Die Datei person_insert.jsp kann wieder mit Hilfe von
person.jsp erstellt werden. Es funktioniert so:
Wenn die Schaltfläche "Datensatz einfügen" gedrückt wird, wird
man auf eine neue Seite "insert.jsp" umgeleitet. Diese sieht
genau gleich aus, hat aber leere Textfelder für die Eingabe vom
Name und Vorname. Die eingegeben Werte werden in die
Tabelle eingefügt und man gelangt wieder zur Ausgangsseite.
Programmcodes:
<% //person_insert.jsp %>
<%@page language="java" import="java.sql.*"%>
<%@ include file="connect.jsp" %>
<%
Class.forName(driver);
Connection con = DriverManager.getConnection(connection,username,password);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM person");
rs.last();
int nbRecords = rs.getRow();
rs.first();
if (request.getParameter("insert") != null)
{
response.sendRedirect("insert.jsp");
return;
}
%>
<html>
<head><title>person</title></head>
<body >
<form name="form1" method="get" action="">
<p>Name:<input type="text" name="tName" value="<%=rs.getObject("name")%>"></p>
<p>Vorname:<input name="tVorname" type="text"
value="<%=rs.getObject("vorname")%>"></p>
<p><input name="insert" type="submit" value="Datensatz einfügen"></p>
</form>
<p>Anzahl Datensätze <%= nbRecords %></p>
</body>
</html>
<%
rs.close();
con.close();
%>
----------------------insert.jsp ----------------------------------------<% // insert.jsp %>
<%@ page language="java" import="java.sql.*"%>
<%@ include file="connect.jsp" %>
<%
String vName = "";
String vVorname = "";
String msg = "";
String sql = "";
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 46
if (request.getParameter("insert") != null)
{
vName = request.getParameter("tName");
if (vName == null || vName.equals( "" ))
msg = "Bitte Name eingeben.";
vVorname = request.getParameter("tVorname");
if (vVorname == null || vVorname.equals( "" ))
msg = msg + " Der Vorname fehlt.";
if (msg.equals( "" ))
{
sql = "INSERT INTO person (name, vorname) VALUES ('"+vName+"', '"+
vVorname+"')";
Class.forName(driver);
Connection con = DriverManager.getConnection(connection,username,
password);
Statement stmt = con.createStatement();
stmt.executeUpdate(sql);
msg = "Datensatz wurde eingefügt";
con.close();
response.sendRedirect("person_insert.jsp");
return;
}
}
if (request.getParameter("cancel") != null)
{
response.sendRedirect("person_insert.jsp");
return;
}
%>
<html>
<head><title>insert</title></head>
<body onLoad = "document.form1.tName.focus()">
<form name="form1" method="get" >
<p>Name:<input name="tName" type="text" value ="<%= vName %>"></p>
<p>Vorname:
<input name="tVorname" type="text" value ="<%= vVorname %>"></p>
<p><input name="insert" type="submit" value="Datensatz einfügen">
<input name="cancel" type="submit" value="Abbrechen"></p>
</form>
<p><%= msg %></p>
</body>
</html>
Erläuterungen zum Programmcode:
Das Umleiten auf eine neue Seite erfolgt mit
response.sendRedirect("insert.jsp");
insert.jsp
Die Eingabe wir auf "leer" überprüft.
In langen Eingabe-Formularen ist es ärgerlich, wenn man wegen eines fehlerhaften Eintrags,
alle Felder neu eingeben muss. Das kann man umgehen, in dem man die bereits richtig
eingegeben Werte in Variablen speichert (vName, vVorname) und sie wiederholt anzeigt.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 47
Man muss auch die Möglichkeit haben, die Eingabe abzubrechen. Das erfolgt mit der
Schaltfläche "Abbrechen". Man prüft mit
if (request.getParameter("cancel") != null)
ob diese Schaltfläche gedrückt wurde, falls ja, wir man mit
response.sendRedirect("person_insert.jsp");
auf die Ausgangsseite zurückgeführt.
6.5.5 Navigation
Als Vorlage für diese Datei können Sie den Coder der Datei
person.jsp übernehmen und es mit den Schaltflächen "first",
"prev", "next", "last" ergänzen.
Programmcode:
<% //person_navig.jsp %>
<%@page language="java" import="java.sql.*" %>
<%@ include file="connect.jsp" %>
<%
Class.forName(driver);
Connection con = DriverManager.getConnection(connection,username,password);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM person");
// anzahl Datensätze
rs.last();
int nbRecords = rs.getRow();
rs.first();
int btnNb = -1;
btnNb = request.getParameter("first") == null ? btnNb : 0;
btnNb = request.getParameter("prev") == null ? btnNb : 1;
btnNb = request.getParameter("next") == null ? btnNb : 2;
btnNb = request.getParameter("last") == null ? btnNb : 3;
String nbRecStr = request.getParameter("nbRec"); //hidden Feld
int nbRec = 1;
if (!(nbRecStr == null || nbRecStr.equals("")))
nbRec = Integer.parseInt(nbRecStr);
switch (btnNb)
{
case 0:
rs.first();
break;
case 1:
if (nbRec > 1)
rs.absolute(nbRec - 1);
break;
case 2:
if (nbRec < nbRecords)
rs.absolute(nbRec + 1);
else
rs.last();
break;
case 3:
rs.last();
break;
}
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 48
%>
<html>
<head><title>person_navig</title></head>
<body>
<form name="form1" method="get" action="">
<p>Name:<input type="text" name="tName" value="<%=rs.getObject("name")%>"></p>
<p>Vorname: <input name="tVorname" type="text"
value="<%=rs.getObject("vorname")%>"> </p>
<table width="25%" border="0">
<tr>
<td width="26%"><input name="first" type="submit" value="first"></td>
<td width="26%"><input name="prev" type="submit" value="prev"></td>
<td width="25%"><input name="next" type="submit" value="next"></td>
<td width="23%"><input name="last" type="submit" value="last"></td>
</tr>
</table>
<p><input type="hidden" name="nbRec" value="<%=rs.getRow()%>"></p>
</form>
<p>Anzahl Datensätze: <%= nbRecords %></p>
</body>
</html>
<%
rs.close();
con.close();
%>
Erläuterungen zum Programmcode:
Um die Navigation zu programmieren, benötigen wir die Methoden:
rs.first();
stellt den Zeiger auf den ersten Datensatz
rs.last();
stellt den Zeiger auf den letzten Datensatz
rs.absolute(nr)
stellt den Zeiger auf den Datensatz nr
Beim ersten und letzten Datensatz darf nicht mehr rückwärts bzw. vorwärts geblättert werden.
Registrieren, welche Schaltfläche gedrückt wurde, erfolg hier auf eine abgekürzte Art.
btnNb = request.getParameter("first") == null ? btnNb : 0;
Man benutzt für alle Buttons die gleiche Variable btnNb. Diese wird beim Button first auf 0
gesetzt, falls first gedrückt wird, sonst behält diese Variable ihren Wert.
6.5.6 Liste alle Datensätze
Die Datensätze werden mit einer do-while
Schleife angezeigt, die abbricht, falls kein
nächstes Element existiert.
do
{
<%=rs.getObject("name")%>
<%=rs.getObject("vorname")%>
} while(rs.next());
Um das aktuelle Datum anzuzeigen,
braucht man die Methode Date() aus der Klasse "java.util.Date".
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 49
Programmcode: Liste aller Datensätze:
<%@page language="java" import="java.sql.*" import="java.util.Date"%>
<%@ include file="connect.jsp" %>
<%
String vDatum = "";
Date d = new Date();
int t = d.getDate();
int m = d.getMonth() + 1;
int y = d.getYear()-100;
String ad = t + "." + m + ".200" + y;
vDatum = ad;
%>
<%
Class.forName(driver);
Connection con = DriverManager.getConnection(connection,username,password);
Statement stmt= con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM person ORDER BY name, vorname");
Object rs_data;
rs.last();
int nbRecords = rs.getRow();
rs.first();
%>
<html>
<head><title>person_liste</title></head>
<body>
<p></p>
<font face="Arial, Helvetica, sans-serif" size="2">
<p>Liste aller Datensätze</p>
<p>Stand: <%=ad%></p>
<form name="form1" method="get" action="">
<table width="42%" border="1" cellpadding="0" cellspacing="0">
<tr bgcolor="#66CCCC">
<td width="42%">Name</td>
<td width="58%">Vorname</td>
</tr>
<%
do
{%>
<tr>
<td><%=rs.getObject("name")%> </td>
<td><%=rs.getObject("vorname")%> </td>
</tr>
<%} while(rs.next()); %>
</table>
</form>
<p>Anzahl Datensätze: <%= nbRecords %></p>
</font>
</body>
</html>
<%
rs.close();
con.close();
%>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 50
6.6 Datenbank-Grundoperationen zusammengefasst
Programmcode: Applikation mit allen Funktionen
<% //person_all.jsp %>
<%@page language="java" import="java.sql.*"%>
<%@ include file="connect.jsp" %>
<%
String sql = "SELECT * FROM person";
String suchName = "";
String msg = "";
ResultSet rs;
boolean isEmpty;
int nbRecords = 0;
int nbRec = 1;
Class.forName(driver);
Connection con = DriverManager.getConnection(connection,username,password);
Statement stmt = con.createStatement();
//insert
if (request.getParameter("insert") != null)
{
response.sendRedirect("insert.jsp");
return;
}
//update
if (request.getParameter("update") != null)
{
sql = "UPDATE person SET name = '"+request.getParameter("tName") +
"',vorname = '" +
request.getParameter("tVorname")+"'WHERE id = '"+
request.getParameter("aktId")+"'";
stmt.executeUpdate(sql);
msg = " Datensatz wurde aktualisiert";
}
//delete
if (request.getParameter("delete") != null)
{
sql = "DELETE FROM person WHERE id = '"+request.getParameter("aktId")+"'";
stmt.executeUpdate(sql);
msg = " Datensatz wurde gelöscht";
}
//search
suchName = request.getParameter("sName");
if (suchName == null || suchName.equals( "" ))
{
sql = "SELECT * FROM person";
rs = stmt.executeQuery(sql);
msg = " Alle Datensätze ausgewählt";
}
else
{
sql = "SELECT * FROM person WHERE name = '" + suchName + "'";
rs = stmt.executeQuery(sql);
msg = " Suchen mit leerem Namen klicken, um alle Datensätze auszuwählen.";
}
isEmpty = !rs.next();//keine Datensätze gefunden
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 51
if (isEmpty)
{
stmt = con.createStatement();
rs = stmt.executeQuery( "SELECT * FROM person");
msg = " Keine Datensätze gefunden. Alle Datensätze ausgewählt";
}
//nbRecords
rs.last();
nbRecords = rs.getRow();
rs.first();
// navigate
int btnNb = -1;
btnNb = request.getParameter("first") == null ? btnNb : 0;
dann = aktuelle btnNb, sonst 0
btnNb = request.getParameter("prev") == null ? btnNb : 1;
btnNb = request.getParameter("next") == null ? btnNb : 2;
btnNb = request.getParameter("last") == null ? btnNb : 3;
// fall leer,
String nbRecStr = request.getParameter("nbRec"); //hidden Feld
if (!(nbRecStr == null || nbRecStr.equals("")))
nbRec = Integer.parseInt(nbRecStr);
switch (btnNb)
{
case 0:
rs.first();
break;
case 1:
if (nbRec > 1)
rs.absolute(nbRec - 1);
break;
case 2:
if (nbRec < nbRecords)
rs.absolute(nbRec + 1);
else
rs.last();
break;
case 3:
rs.last();
break;
}
if (request.getParameter("update") != null)
rs.absolute(nbRec); //show update record
%>
<html>
<head><title>person_all</title></head>
<body >
<form name="form1" method="get" action="">
<p>Name:<input type="text" name="tName" value="<%=rs.getObject("name")%>"></p>
<p>Vorname:
<input name="tVorname" type="text" value="<%=rs.getObject("vorname")%>"> </p>
<table width="24%" border="0">
<tr>
<td width="26%"><input name="first" type="submit" value="first"></td>
<td width="27%"><input name="prev" type="submit" value="prev"></td>
<td width="26%"><input name="next" type="submit" value="next"></td>
<td width="21%"><input name="last" type="submit" value="last"></td>
</tr>
</table>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 52
Suchen nach:<input name="sName" type="text" value = "<%=suchName == null?
"":suchName%>" >
<input name="search" type="submit" value="Suchen"><%= msg %>
<input type="hidden" name="aktId" value="<%=rs.getObject("id")%>">
<input type="hidden" name="nbRec" value="<%=rs.getRow()%>">
<input name="update" type="submit" value="Aktualisieren">
<input name="delete" type="submit" value="Löschen">
<input name="insert" type="submit" value="Einfügen">
</form>
<p>Anzahl Datensätze: <%= nbRecords %></p>
</body></html>
<%
rs.close();
con.close();
%>
Die Datei "insert.jsp" kann nach der Änderung der redirect-Adresse übernommen werden.
6.7 Zugriff mit einem Passwort schützen, Session-Variablen
login.jsp
Der Zugriff auf eine Webdatenbank oder zumindest
Mutationsfunktionen müssen in der Regel mit einem
Password
Passwort geschützt werden. Man stellt eine LoginAnmeldung
ungültig
erfolgreich
Seite voran, in der ein Password eingegeben und
geprüft wird. Damit das Passwort in der Adresszeile
des Browsers nicht sichtbar ist, muss im HTML-Teil
keinzugriff.htm
person_login.jsp
statt der Methode "GET" die Methode "POST"
verwendet werden.
Schwierigkeiten macht dabei die Statuslosigkeit von HTTP (Seine kap. 5.2.). Nach dem der
Server eine JSP-Seite ausgeführt hat, "vergisst" er alle Parameter. Wenn wir ein Wert (z.B.
Passwort) über mehrere Seiten brauchen, muss dieser in einer Session-Variablen gespeichert
werden.
In der Seite login.jsp wird die Session Variablen "pwd" definiert.
session.setAttribute("pwd", vPassword);
In der Seite person_login, wird der Inhalt der Sessionvariabel in "logPassword" gespeichert.
String logPassword = (String)session.getAttribute("pwd");
Programmcode:
<% //login.jsp %>
<%@ page language="java" import="java.sql.*" %>
<%@ include file="connect.jsp" %>
<%!
String vPassword = "";
String msg = "";
%>
<%
if (request.getParameter("login") != null)
{
vPassword = request.getParameter("tPassword");
if (vPassword == null || vPassword.equals( "" ))
{
msg = " Bitte Password eingeben.";
}
else if (vPassword.equals("qwe"))
{
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 53
msg = "";
session.setAttribute("pwd", vPassword);
response.sendRedirect("person_login.jsp");
return;
}
else
msg = "Password ist ungültig";
}
%>
<html> (ohne Formatierung)
<head><title>login</title></head>
<body onLoad = "document.form1.tPassword.focus()">
<p>Login / Session-Variablen</p>
<form name="form1" method="post" action="">
Password<input name="tPassword" type="password" >Testpassword: qwe
<input name="login" type="submit" value="Einloggen">
</form>
<p><%=msg%></p>
</body>
</html>
-----------------------person_login.jsp----------------------------------<% //person_login.jsp %>
<%@page language="java" import="java.sql.*" %>
<%@ include file="connect.jsp" %>
<%
String logPassword = (String)session.getAttribute("pwd");
if (logPassword == null || !logPassword.equals("qwe"))
{
response.sendRedirect("keinzugriff.htm");
return;
}
if (request.getParameter("logout") != null)
{
session.invalidate();
response.sendRedirect("keinzugriff.htm");
}
Class.forName(driver);
Connection con = DriverManager.getConnection(connection,username,password);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM person");
// nbRecords
rs.last();
int nbRecords = rs.getRow();
rs.first();
%>
<html>
<head><title>person_login</title></head>
<body>
<form name="form1" method="get" action="">
Name: <input type="text" name="tName" value="<%=rs.getObject("name")%>">
Vorname:<input name="tVorname" type="text" value="<%=rs.getObject("vorname")%>">
<input name="logout" type="submit" value="Abmelden">
</form>
<p>Anzahl Datensätze <%= nbRecords %></p>
</body>
</html>
<%
rs.close();
con.close();
%>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 54
7. PHP
7.1 PHP – Bedeutung
PHP (ursprünglich Personal Home Page Tools, heute PHP Hypertext Preprozessor) ist eine in
HTML eingebettete Skriptsprache für die dynamische Erzeugung von Webseiten. Im Gegensatz
zu clientseitigen Scriptsprachen wie JavaScript, wird PHP auf dem Server ausgeführt. PHPSkripte werden im Vorfeld nicht kompiliert (im Unterschied zu JSP).
PHP verfügt über einen grossen Umfang an fertigen Funktionen für alle Anwendungsbereiche
und wird verwendet z.B. für:
 Erzeugung von dynamischen Webseiten
 Auswertung von Formularen im Web
 Senden und Empfangen von Cookies
 Zugriff auf Serverdatenbanken (z.B. MySQL).
Wie funktioniert PHP?
Apache Webserver
Client
HTML-Dokument
mit PHP-Code
http://....../test.php
test.php
Rückgabe von neuem HTML-Code, ev.
mit mySQL-Daten
mySQL DB
PHP-Parser
PHP-Parser führt
PHP-Code aus
Der Client führt einen http-Request durch. Innerhalb des HTML-Codes werden PHPAnweisungen untergebracht. Sobald ein PHP-Skript aufgerufen wird, wird auf dem Webserver
ein zusätzliches Programm gestartet, der PHP-Parser. Dieser liest den PHP-Quellencode,
übersetzt ihn in Maschinencode und führt ihn aus. Der Browser des Clients hat mit der Ausführung der PHP-Anweisungen nichts zu tun, alle PHP-Anweisungen werdern serverseitig ausgeführt. Im Browser sind PHP-Anweisungen nicht sichtbar (im Unterschied zu JavaScript).
Nachteil des PHP gegenüber JSP ist die Leistungsfähigkeit. PHP-Quellencode muss bei jedem
Aufruf übersetzt werden. JSP wird kompiliert und daher bei wiederholter Verwendung viel
schneller ausgeführt. Je grösser die Programme, desto länger benötigt der Computer, um den
Quellencode in Maschinensprache zu transformieren. Deshalb eignet sich PHP eher für einfachere und kurze Programme.
7.2 Syntax, Datentypen, Variablen, Operatoren
 Syntax
 Der PHP-Code wird in HTML-Code mit folgenden Zeichen eingebettet:
<?PHP
?>
oder auch nur
<?
?>
 Jede Anweisung endet mit einem Semikolon ;
 Gross- /Kleinschreibung wird nicht berücksichtigt

Kommentare // bzw. /* */
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 55
 Datentypen
boolean, integer, double, string, array
 Variablen
Variablennamen beginnen immer mit $. Gross-/Kleinschreibung wird berücksichtigt. Wir schreiben Variablennamen klein.
Variablen in PHP müssen nicht deklariert werden. PHP erkennt den Typ der Variablen selbst, je
nach Anweisungen und führt eine automatische Typekonvertierung durch.
$a = 10; //integer
$b = 10.5; // double
$c = $a + $b; //double Umwandlung automatisch
is_integer($var);
Diese Funktion prüft, ob die Variable $var vom Datentyp integer ist und gibt eine 1 zurück, ansonsten wird eine 0 zurückgegeben.
$a = (int)$var; Der Cast Operator (int) wandelt $var in ein Integer-Wert.
Variablen sind grundsätzlich innerhalb des Blocks, in dem sie deklariert wurden, gültig.
 Konstanten
Konstanten werden einmal definiert und mit einem bestimmten Wert versehen, der später nicht
mehr korrigiert werden kann.
define ("PI", 3.14159);
 Pointer (Zeiger)
<?
$text = "Hallo";
$zeiger = $text;
echo $zeiger;
?>
Ergibt Hallo. Die Pointer ändern auch nach der Zuweisung ihren Wert, wenn sich der Wert der
Variablen ändert, auf die sie verweisen.
 Arithmetische Operatoren: + , - , *, / , %
 Zusammensetzung der Strings
$name = "Peter"
$password = "geheim"
$Anwort = "Sie heissen ".$name. " ihr Password ist ".$password;
 Vergleichsoperatoren
==, >=, >, <=, <;
datenbanken.docx
!=,
01.01.2013/ J. Arnold
Datenbanken
Seite 56
 Logische Operatoren
&&, || (man kann auch and, or schreiben)
xor
ausschliessendes or
!$a
führt zur Umkehrung des logischen Ausdrucks
7.3 Programmsteuerung
Die meisten Programmstrukturen haben die gleiche Funktion und die gleiche Syntax wie in Java, deshalb werden sie nur kurz beschrieben.
 Bedingungen auswerten mit if - else
if (Bedingung)
{
Anweisungen
}
else
{
Anweisungen
}
 Mehrere Zustände auswerten mit switch
switch ($auswahl)
{
case 1:
Anweisung1;
break;
case 2:
Anweisung2;
break;
....
default:
Anweisung;
}
 Schlaufen durchlaufen mit while
while (Bedingung)
{
Anweisungen
}
 Schlaufen durchlaufen mit for
for (Startwert; Abbruchbedingung; Veränderung)
{
Anweisungen
}
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 57
7.4 Ausgabe-Befehle
 echo
echo "Die Eingabe ist falsch";
echo "<p> Die Eingabe ist falsch.</p>"; kommt auf eine neue Zeile
 Formatierte Ausgabe printf ('%.4f', $x); gibt den Wert der Variablen x mit vier Stellen
Beispiel: Formatierte Ausgabe von Wurzelzahlen:
<?PHP // ex1.php
echo "<p>Berechnet Wurzelzahlen</p>";
for ($i = 1; $i < 10; $i++)
echo sqrt( $i).'<br>';
echo"<p>Formatierte Ausgabe </p> ";
for ($i = 1; $i < 10; $i++)
{
printf('%.3f',sqrt( $i));
echo '<br>';
}
?>
 Runden round($wert, 2) rundet den Wert auf zwei Stellen
7.5 Arrays
Arrays sind Datenfelder, die mehrere Werte vom gleichen Typ speichern können. Die einzelnen
Werte können über einen ganzzahligen Index angesprochen werden.
0
1
2
3
Arni
Bauer
Meier
Zaug
Der Index beginnt immer bei 0.
Erzeugung eines Arrays:
$name[0] = "Arni";
$name[1] = "Bauer";
$name[2] = "Meier";
$name[3] = "Zaug";
oder:
$name = array("Arni", "Bauer", "Meier", "Zaug");
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 58
oder mit einer Schleife:
<?PHP
for ($i = 0; $i < 10; $i++)
{
$zahl[$i] = $i;
}
echo ($zahl[1] + $zahl[3] + $zahl[5]);
//addiert die zweite, vierte
und die sechste Zahl
?>
 Ausgabe aller Werte des Arrays mit einer for-Schleife:
for ($i = 0; $i < 10; $i++)
$zahl[$i] = $i;
//erzeugt ein Array mit 10 Zahlen
for ($i = 0; $i < 10; $i++)
echo "<p> $zahl[$i] </p> ";
//gibt die Elemente des Arrays aus
 Array durchlaufen mit foreach
Für das Auswerten von Arrays ist die foreach-Schleife einfacher als die for-Schleife, da man im
Voraus nicht wissen muss, wie viele Elemente ein Array hat..
$name = array("Bauer", "Arni", "Zaug", "Peter");
foreach($name as $element)
{
echo $element."<br>";
}
Einige Array-Funktionen mit Beispielen
 count($a)
 array_sum($a)
gibt die Anzahl der Werte im Array $a an
gibt die Summe der Werte im Array $a an
<?PHP //ex2.php
echo "<p>Array mit 10 Zahlen:</p>";
for ($i = 0; $i < 10; $i++)
$zahl[$i] = $i;
for ($i = 0; $i < 10; $i++)
echo $zahl[$i]. "
";
echo "<p>Summe des 2.,4.und 6.Wertes ist ".($zahl[1] + $zahl[3] +
$zahl[5])."</p>";
echo "<p> Anzahl Werte ".count($zahl). "</p>";
echo "<p>Summe aller Werte ".array_sum($zahl). "</p>";?>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
 sort ($a)
Seite 59
sortiert das Array $a aufsteigend
<?PHP //ex3.php
$name = array("Peter", "Arni", "Zaug", "Bauer");
sort($name);
for ($i = 0; $i < 4; $i++)
echo $name[$i]."
";
?>
 rsort($a)
sortiert das Array $a absteigend
 foreach($a)
Anstelle einer for-Schleife kann ein Array mit foreach durchgesucht werden. Mit foreach wird jeder Wert des Arrays vorrübergehend einer Variable zugeordnet und dann z.B ausgegeben.
$name = array("Peter", "Arni", "Zaug", "Bauer");
foreach($name as $n)
echo $n,"<br>";
 rand(min, max)
Zufallszahlen
rand() gibt eine Zufallszahl zwischen min und max zurück. Die Parameter min und max sind optional. Wenn Sie keine Argumente übergeben, werden Zufallszahlen zwischen 0 und dem plattformabhängigen Maximalwert (meistens 2 31 ) geliefert. Dieser Maximalwert kann mit
getrandmax() ermittelt werden.
 array_count_values
zählt, wie oft ein Element im Array vorkommt
Bsp: Häufigkeit von Würfelzahlen
<?PHP // ex4.php
echo "<p>Arrays mit zufälligen Würfelzahlen </p>";
echo "<p>Zählt, wie offt jede Zahl vorkommt </p>";
for ($i = 0; $i < 30; $i++)
$zahl[$i] = rand(1,6);
$zaehle = array_count_values($zahl);
while(list($key, $val) = each($zaehle))
{
echo $key . " : " . $val . "mal<br>";
}
?>
7.5 Datumfunktionen
<?
$datum = getdate();
$tag = $datum['mday'];
$monat = $datum['month'];
$jahr = $datum['year'];
$wochentag =$datum['weekday'];
echo "Heute ist ". $wochentag.", den ". $tag .". ".$monat." ".$jahr;
?>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 60
7.6 Funktionen und Unterprogramme
Es kommt recht häufig vor, besonders bei grösseren Projekten, dass sich der Code wiederholt.
Mittels Funktionen kann man Teil-Programme (Teil-Berechnungen) definieren und mit verschiedenen Parametern aufrufen.
Allgemeine Form:
function funktionsname ($parameter)
{
Anweisungen...
return $rueckgabeparameterwert;
}
Bsp.
function mittelwert ($a , $b)
{
$mw = ($a + $b)/2;
return $mw;
}
echo mittelwert (3, 5);
include()
Bestimmte Programmteile, insbesondere Programmteile, die mehrmals verwendet werden,
können in eine separate Datei ausgelagert werden, die mit include() im Hauptprogramm integriert wird. Im folgenden Beispiel wird der Inputcheck in der Datei che.inc.php gespeichert und
mit include("check.inc.php") aufgerufen.
<?php //ex5d.php Eingabe überprüfen
$name = "";
<?php //check.inc.php
$alter = "";
if (empty ($name))
$msg = " ";
$msg = "Bitte Name
$antwort = "";
eingeben." ;
if (isset($_POST["Submit"]))
{
if (empty ($alter))
$name = $_POST["tName"];
$msg .= " Bitte Alter
$alter = $_POST["tAlter"];
eingeben." ;
include("check.inc.php");
else
if($msg != " " )
{
$antwort = $msg;
if (!is_numeric($alter))
else
$msg .= " Das Alter
$antwort = "Ihr Name ist ".$name."<br>"."
ist ungültig. ";
Ihr Alter ist ".$alter;
}
}
?>
?>
<html>
<head><title>ex5c</title></head>
<body>
<form name = "form1" method = "post" action = "">
<p>Name:<input type="text" name="tName" value="<?php echo $name ?>"></p>
<p>Alter : <input type="text" name = "tAlter" "<?php echo $alter ?>"></p>
<p><input type="submit" name = "Submit" value = "Submit"></p>
<p><? echo $antwort ?> </p>
</form>
</body>
</html>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 61
7.7 Formularauswertung mit PHP
Bei der Formularauswertung werden die Funktionen empty() und isset() benutzt.
empty($var)
true, wenn eine Variable nicht definiert ist, oder gleich 0 ist
isset($var)
true, wenn eine Variable oder Array existieren
Bsp: Eingabe mit Formularfeldern
<?php //ex5.php
$name = "";
$alter = "";
$antwort = "";
if (isset($_POST["Submit"]))
{
$name = $_POST["tName"];
$alter = $_POST["tAlter"];
$antwort = "Ihr Name ist ".$name."<br>"."Ihr Alter ist ".$alter;
}
?>
<html>
<head><title>ex5</title></head>
<body onLoad = "document.form1.tName.focus()">
<form name = "form1" method = "post" action = "">
<p>Name:<input type="text" name = "tName"></p>
<p>Alter: <input type="text" name = "tAlter"></p>
<p><input type="submit" name = "Submit" value = "Submit"> </p>
<p><? echo $antwort ?> </p>
</form>
</body>
</html>
Erläuterungen zum Programmcode:
if (isset($_POST["Submit"])) überprüft, ob die Schaltfläche Submit gedrückt wurde.
$name = $_POST["tName"];
speichert den Inhalt des Textfeldes tName in die
Variable $name.
<? echo $antwort ?>
Schreibt den Inhalt der Variablen $antwort aus.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 62
Eingabe überprüfen
Mit der Funktion empty() kann überprüft werden, ob die beiden Eingabefelder ausgefüllt wurden.
Die Zahleneingabe überprüft man am einfachsten mit der
Methode is_numeric
if (!is_numeric($alter))
Falls anstelle einer Zahl eine Zeichenkette eingegeben wurde, wird eine Fehlermeldung ausgegeben.
Damit bei Eingabekorrekturen die bereits richtige Eingaben nicht erneut eingegeben werden
müssen, lässt man im Textfeld tName den Wert der Variablen $name erscheinen.
<input type="text" name = "tName" value="<?php echo $name;?>">
<?php //ex5b.php Eingabe überprüfen
$name = "";
$alter = "";
$error_msg = " ";
$antwort = "";
if (isset($_POST["Submit"]))
{
$name = $_POST["tName"];
if (empty ($name))
$error_msg = "Bitte Name eingeben." ;
$alter = $_POST["tAlter"];
if (empty ($alter))
$error_msg .= " Bitte Alter eingeben." ;
else
{
$alter = $_POST["tAlter"];
if (!is_numeric($alter))
$error_msg .= "Das Alter ist ungültig. ";
}
if($error_msg != " " )
$antwort = $error_msg;
else
$antwort = "Ihr Name ist ".$name."<br>"."Ihr Alter ist ".$alter;
}
?>
<html>
<head><title>ex5c</title></head>
<body onLoad = "document.form1.tName.focus()">
<form name = "form1" method = "post" action = "">
<p>Name:<input type="text" name = "tName"
value="<?php echo $name;?>"></p>
<p>Alter : <input type="text" name = "tAlter"
value = "<?php echo $alter;?>"></p>
<p><input type="submit" name = "Submit" value = "Submit"> </p>
<p><? echo $antwort ?> </p>
</form>
</body>
</html>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 63
7.8 GET und POST
In einem Formular geben Sie im Form-Tag mit der GET- oder POST- Methode an, wie die Formulardaten übermittelt werden sollen.
<form method = "post" action = "ex5.php">
<form method = "get" action = "ex5.php">
Bei der Methode get werden die Daten aus dem Formular direkt an die bei der Übertragung
aufgerufene URL angehängt. Sie sehen dann in der Adresszeile des Browsers alle Formulardaten und Variablen-Werte.
http://...../ex5.php?tName=Peter&tAlter=25&Submit=Submit
Bei der Methode POST werden die Formularwerte im Körper der Nachricht übermittelt. Die
Formulardaten sind im URL nicht mehr sichtbar.
Mit der Methode POST können grössere Datenmengen übermittelt werden, währen bei GET die
Menge etwa auf 2 KB beschränkt ist.
Um die Formulare auf Fehler zu überprüfen, wird häufig die Methode GET benutzt, sonst benutzt man mit Vorteil die Methode POST.
7.9 Weitere Formularelemente (Radio, Checkbox, Optionsliste)
Bsp. (ex6.php)
Verwendet werden folgende Formularelemente:
- Textfeld
- Radiobuttons
- Checkboxen
- Auswahlliste
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 64
Die Auswertung des Formulars wird oft auf einer neuen Webseite präsentiert. Da hier nur die
Funktionalität getestet wird, wird der Inhalt der Formularelemente in der gleichen Datei ausgegeben.
Programmcode zum Beispiel Formularauswertung:
<?php //ex6.php
$name = "";
$anrede = "";
$fach = "";
$sprache = "";
$sprache_text = "";
if (isset($_POST["Submit"]))
{
$name = $_POST["tName"];
$anrede = $_POST["rAnrede"];
$fach = $_POST["aSelect"];
$sprache = $_POST['sprache']; //Inhalt der Checkboxen
$sprache_text = "Sprache: ".implode(', ',$sprache);
}
?>
<html>
<head><title>ex6.php</title></head>
<body onLoad = "document.form1.tName.focus()">
<form name="form1" method = "post" action = "">
<p>Name<input type="text" name = "tName" ></p>
<p>
<input type="radio" name="rAnrede" value="Herr" checked> Herr
<input type="radio" name="rAnrede" value="Frau">Frau </p>
<p>
<select name="aSelect">
<option>Studienfach</option>
<option>Informatik</option>
<option>Biologie</option>
<option>Chemie</option>
</select></p>
<p><input type="checkbox" name="sprache[]" value="Deutsch" checked>
Deutsch<br>
<input type="checkbox" name="sprache[]" value="Französisch">
Französisch<br>
<input type="checkbox" name="sprache[]" value ="Englisch"> Englisch</p>
<p><input type="submit" name = "Submit" value = "Submit"> </p>
<p><? echo $name ?> </p>
<p><? echo $anrede ?> </p>
<p><? echo $fach ?> </p>
<p><? echo $sprache_text ?> </p>
</form></body></html>
Bemerkungen zum Programmcode:
Radiobuttons einer Gruppe haben den gleichen Namen "rAnrede" , dadurch kann nur eine Option gewählt werden (entweder Herr oder Frau).
Bei den Checkboxen sind mehrere Optionen möglich. Damit die Auswertung auch bei mehreren
ausgewählten Optionen funktioniert, wird eine Array-Variable sprache[] verwendet. Mit
$sprache_text = implode(', ',$sprache);
werden mehrere Auswahloptionen getrennt mit Komma zu einem Text zusammengefasst.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 65
implode verbindet Arrya-Elemente zu einem String
explode zerlegt ein String anhande des Trennzeichens
7.10 Mailer (Online Mitteilung automatisch verschicken)
Mit Hilfe dieses Programms hat der Internetsurfer eine Möglichkeit, eine Mitteilung zurück zu
schicken. Die Formulardaten werden an eine im Programmcode eingegeben e-Mail-Adresse
verschickt. Die Eingabe wird überprüft: Die Felder dürfen nicht leer sein, die Email muss ein
"@" enthalten. Falls es nicht der Fall ist, erscheint eine Fehlermeldung und erneut das Formular
mit bereits richtig eingetragenen Feldern.
Programmcode:
<?php //mailer.php schickt die Formulardaten an den Recipient
$recipient = "[email protected]";
$error_msg = "";
$dank_msg = "";
if (isset($_POST["Submit"]))
{
$name = $_POST["tName"];
if (strlen($name) == 0)
$error_msg = "<p>Es wurde kein Name eingegeben!</p> ";
$email = $_POST["tMail"];
if (strlen($email) == 0)
$error_msg .= "<p>Es wurde keine Email-Adresse eingegeben!</p>";
else if (!preg_match ("/@/", $email))
$error_msg .= "<p>Die Email-Adresse ist ungültig!</p>";
$mitteilung = $_POST["tMitteilung"];
if (strlen($mitteilung) == 0)
$error_msg .= "<p>Sie haben Ihre Mitteilung vergessen!</p>";
if($error_msg)
{
echo "Ihre Mitteilung konnte nicht verschickt werden: <br> ";
echo $error_msg;
echo "<p><br>Bitte klicken Sie auf <a
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 66
href=javascript:history.back(1)> zurück</a> und füllen Sie das
Formular vollständig aus!</p>";
}
else
{
//eMail vorbereiten
$subjekt = "Mitteilung aus dem Internet";
$header = "From: ".$email. "\n";
$mail_body = "Datum: ".date("d.m.Y"). "\n";
$mail_body .= "Name: " . $name . "\n";
$mail_body .= "eMail: " . $email . "\n";
$mail_body .= "Mitteilung: " .$mitteilung ."\n";
mail($recipient, $subjekt , $mail_body, $header);
$dank_msg = "Vielen Dank für Ihre Mitteilung.";
}
}
?>
<html>
<head><title>mailer</title></head>
<body onLoad = "document.form1.tName.focus()">
<p><font face="Verdana, Arial, Helvetica, sans-serif" size="3">
<p> </p>
<p>Online Mitteilung</p>
<form name="form1" method="post" action="mailer.php">
<table width="97%" border="0" bordercolor="#66CCCC" bgcolor="#66CCCC">
<tr bgcolor="#66CCCC">
<td width="29%"><div align="right"></div></td>
<td width="71%"> </td>
</tr>
<tr bgcolor="#66CCCC">
<td><div align="right">Name und Vorname: </div></td>
<td><input name="tName" type="text" size="44"></td>
</tr>
<tr bgcolor="#66CCCC">
<td><div align="right">Ihre eMail-Adresse:</div></td>
<td><input name="tMail" type="text" size="44"></td>
</tr>
<tr bgcolor="#66CCCC">
<td valign="top"><div align="right">Ihre Mitteilung:</div></td>
<td><textarea name="tMitteilung" cols="40" ></textarea></td>
</tr>
<tr bgcolor="#66CCCC">
<td> </td>
<td><input type="submit" name="Submit" value="Abschicken"></td>
</tr>
<tr bgcolor="#66CCCC">
<td> </td>
<td> </td>
</tr>
</table>
</form>
<? echo $dank_msg ?>
</font>
</body>
</html>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 67
8. PHP und MySQL
8.1 MySQL – PHP – Funktionsbibliothek
Die Leistungsfähigkeit von PHP ergibt sich vor allem aus den umfangreichen Funktionsbibliotheken, die für die Programmierung von Webdatenbanken geeignet sind.
mysql_connect("host","user","passwort")
mysql_close();
Verbindung zum Server herstellen
Verbindung zum Server beenden
mysql_select_db("database");
Eine Datenbank auswählen
$sql = select * from person;
$rs = mysql_query($sql);
Abfrage
Ergebnis der Abrage (Resultset)
$row_rs = mysql_fetch_assoz()
Ergebnisse der Abfrage als Datensätze
$totalRows_rs = mysql_num_row()
Anzahl der Datensätze
mysql_fetch_row
liefert den Datensatz in Form eines Arrays. Zugriff auf Spalten erfolgt mit
$row[$n]
mysql_data_seek($rs, 0)
Geht zum ersten Datensatz
mysql_error()
Fehlermeldung
mysql_free_result($rs);
Gibt die Ressourcen wieder frei
(sollte aufgerufen werden, wenn man
Datenbank nicht mehr braucht)
Bsp1. Datenbankverbindung, Abfrage, Resultsets und Anzahl Datensätze anzeigen
<?php //connect.inc.php
mysql_connect("host","user","password");
Verbindung zur Datenbak
mysql_select_db("database");
?>
<?php
include("connect.inc.php");
$sql = "SELECT * FROM person";
$rs = mysql_query($sql);
$row_rs = mysql_fetch_assoc($rs);
$totalRows_rs = mysql_num_rows($rs);
Holt alle Datensätze aus der
Tabelle person
Anzahl Datensätze
?>
<html>
Der erstel Datensatz wird
<head></head>
angezeigt
<p>Name: <input name="tName" type="text"
value="<?php echo $row_rs['name']; ?>" ></p>
<p>Anzahl Datensätze: <?php echo $totalRows_rs ?> </p>
</body>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 68
</html>
<?php
mysql_free_result($rs);
?>
8.2 Formulardaten in eine Datenbank schreiben
Das unten stehende Beispiel stellt ein einfaches
Formular mit einem Eingabefeld "name" dar. Der
eingegebene Name wird in die Tabelle person, gespeichert.
Mit "Abbrechen" wird die Eingabe nicht in die Datenbank geschrieben, sondern auf eine andere Webseite umgeleitet.
<?php
include("connect.inc.php");
$msg = "";
// Abschicken
if (isset($_POST["Submit"]))
{
$name = trim($_POST["tName"]);
$sql ="INSERT INTO person (name) VALUES ('$name')";
mysql_query($sql);
$msg = "Der Datensatz wurde eigetragen.";
}
// Abbrechen, Umleiten auf eine andere Webseite
if (isset($_POST["Cancel"]))
{
$gehezu = "google.ch";
header(sprintf("Location: %s", $gehezu));
}
?>
<html>
<head><title>u</title></head>
<body>
<form name="form1" method="post" action="u.php">
<table width="70%" border="0">
<tr>
<td width="28%"><div align="right">Name</div></td>
<td width="72%"><input name="tName" type="text"></td>
</tr>
<tr>
<td> </td>
<td><input type="submit" name="Submit" value="Abschicken">
<input name="Cancel" type="submit" value="Abbrechen"></td>
</tr>
</table>
</form>
<p><?php echo $msg ?>  </p>
</body>
</html>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 69
8.3 Online-Anmeldung
Die Online-Anmeldung ist eine häufig verwendete Datenbankapplikation, die im Internet in verschiedensten Formen zu finden ist.
Im folgenden Beispiel werden drei Komponenten gebraucht:
 mySQL Tabelle person
mit den Feldern id (int, not null, auto_increment), name (char 25),
vorname (char 25), anrede (char 4), fach (char 20), sprache (char 20) und email (char 35).
 Formular für Dateneingabe "anmeldung.php"
 Liste der bereits eingetragenen Datensätze "anmeldeliste.php"
Die Formulardaten werden in Variablen
gespeichert, überprüft und dann in der Datenbank gespeichert. Bei der Überprüfung
der Eingaben werden die richtigen Einträge zurückgeholt, damit sie nicht wiederholt
eingegeben werden müssen.
Die Anmeldung wird mit einem Email bestätigt.
Nach dem Abschicken des Formulars werden alle Datensätze in Tabellenform angezeigt. Dieser Schritt ist aus Datenschutzgründen nicht immer zu empfehlen, man
kann aber nach dem Abschicken eine andere Webseite anzeigen.
Die HTM-Darstellung des Formulars erstellt nan vorteilhaft mit Dreamweaver und dann programmiert man den php-Teil. Der vollständige Programmcode der beiden php-Dokumente:
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 70
Programmcode:
<?php
//anmeldung.php Formular für Online-Anmeldung
include("connect.inc.php");
$name = "";
$vorname = "";
$email = "";
$error_msg = "";
//Eingabe überprüfen und in Variablen speichern
if (isset($_POST["Submit"]))
{
$name = trim($_POST["tName"]);
if (strlen($name) == 0)
$error_msg = "Es wurde kein Name eingegeben! ";
$vorname = trim($_POST["tVorname"]);
if (strlen($vorname) == 0)
$error_msg .= "Es wurde kein Vorname eingegeben! ";
$anrede = $_POST["rAnrede"];
$fach = $_POST["aSelect"];
$sprache = $_POST["rSprache"];
$email= trim($_POST["tMail"]);
if (strlen($email) == 0)
$error_msg .= "Es wurde keine Email-Adresse eingegeben!";
else if (!preg_match ("/@/", $email))
$error_msg .= "Die Email-Adresse ist ungültig!";
if($error_msg)
{
echo "Ihre Anmelung ist unvollständig: <br> ";
echo $error_msg;
echo "<p>Bitte füllen Sie das Formular vollständig aus!</p>";
}
else
{
//Daten in die Tabelle einfügen
$sql ="INSERT INTO person (name,vorname,anrede,fach,sprache,email)
VALUES ('$name','$vorname','$anrede','$fach','$sprache','$email')";
mysql_query($sql);
//Email vorbereiten
$recipient = $email;
$subjekt = "Bestaetigung der Anmeldung";
$header = "From: [email protected] \n";
$mail_body = "Datum: ".date("d.m.Y"). "\n";
$mail_body .= "Name: " . $name . "\n";
$mail_body .= "Vorname: " . $vorname . "\n";
$mail_body .= "Email: " . $email . "\n";
$mail_body .= "Fach: " . $fach . "\n";
$mail_body .= "Sprache: " . $sprache . "\n\n";
$mail_body .= "Wir haben Ihre Anmeldung erhalten.\n";
mail($recipient, $subjekt , $mail_body, $header);
//redirect zur Teilnehmenliste
$insertGoTo = "anmeldliste.php";
header(sprintf("Location: %s", $insertGoTo));
}
}
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 71
// Anmeldung abbrechen
if (isset($_POST["Cancel"]))
{
$insertGoTo = "php_ex.htm";
header(sprintf("Location: %s", $insertGoTo));
}
?>
<html>
<head><title>anmeldung</title></head>
<body onLoad = "document.form1.tName.focus()">
<p><font face="Arial, Helvetica, sans-serif" size="2">
<p>Anmeldeformular.<br>
Eine Anmeldebestätigung erhalten Sie per Email. </p>
<form name="form1" method="post" action="anmeldung.php">
<table width="54%" border="0" bgcolor="#99CCFF">
<tr >
<td width="40%"><div align="right"></div></td>
<td width="60%"> </td>
</tr>
<tr>
<td><div align="right">Name:</div></td>
<td><input name="tName" type="text" value="<?php echo $name;?>"
size="35"></td>
</tr>
<tr >
<td><div align="right">Vorname:</div></td>
<td><input name="tVorname" type="text" value="<?php echo $vorname; ?>"
size="35"></td>
</tr>
<tr >
<td><br><div align="right">Anrede</div></td>
<td><p>
<br>
<input type="radio" name="rAnrede" value="Herr" checked> Herr
<input type="radio" name="rAnrede" value="Frau">Frau </p>
</td>
</tr>
<tr>
<td><br><div align="right">Studienfach:</div></td>
<td><br>
<select name="aSelect">
<option>Informatik</option>
<option>Biologie</option>
<option>Chemie</option>
</select></td>
</tr>
<tr>
<td ><br><div align="right">Sprache:</div></td>
<td><br>
<input type="radio" name="rSprache" value="Deutsch" checked> Deutsch
<input type="radio" name="rSprache" value="Französisch">Französisch
</td>
</tr>
<tr >
<td><br><div align="right">Email:</div></td>
<input name="tMail" type="text" value="<?php echo $email;?>"
size="35"></td></tr>
<tr >
<td> </td>
<td><input type="submit" name="Submit" value="Abschicken">
<input type="submit" name="Cancel" value="Abbrechen">
</tr>
</table>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 72
</form>
</font>
</body>
</html>
--------------------------------------------------------------------------<?php
//anmeldliste.php Stellt erfasste Datensätze in einer Liste dar
include("connect.inc.php");
$query_rs = "SELECT * FROM person";
$rs = mysql_query($query_rs) or die(mysql_error());
$row_rs = mysql_fetch_assoc($rs);
$totalRows_rs = mysql_num_rows($rs);
?>
<html>
<head><title>anmeldeliste</title></head>
<body>
<p><font face="Arial, Helvetica, sans-serif" size="2">
<P>Teilnehmerliste (Stand <?php echo strftime('%d.%m.%Y') ?>)</P>
<table width="88%" bgcollor = "#CCFFFF" border="1" cellpadding="0">
<tr bgcolor="#6699CC">
<td width="7%">id</td>
<td width="13%">Name</td>
<td width="15%">Vorname</td>
<td width="15%">Anrede</td>
<td width="15%">Fach</td>
<td width="15%">Sprache</td>
<td width="21%">Email</td>
</tr>
<?php do { ?>
<tr bordercolor="#CCCCCC">
<td> <?php echo $row_rs['id']; ?></td>
<td> <?php echo $row_rs['name']; ?> </td>
<td> <?php echo $row_rs['vorname']; ?> </td>
<td> <?php echo $row_rs['anrede']; ?> </td>
<td> <?php echo $row_rs['fach']; ?> </td>
<td> <?php echo $row_rs['sprache']; ?> </td>
<td> <?php echo $row_rs['email']; ?> </td>
</tr>
<?php } while ($row_rs = mysql_fetch_assoc($rs)) ; ?>
</table>
<p>Anzahl Anmeldungen: <?php echo $totalRows_rs ?> </p>
</font>
</body>
</html>
<?php
mysql_free_result($rs);
?>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 73
8.4 Online-Inventar
Diese Applikation benötigt ähnliche Funktionen wie die JSP-Applikation im Kapitel 6.4. Es wird
deshalb nur der Programmcode, ohne weitere Erklärungen aufgeführt. Die Applikation dient zur
Online-Erfassung von Büchern. Man benötigt eine MySQL Tabelle "buch" mit den Feldern
"nr" integer not null auto_increment, autor char(25), titel char(25), verlag char(25), jahr char(4),
preis float, standort char(10).
Die Applikation besteht aus den PHP-Dateien
buchinventar.php
buch_insert.php
buch_liste.php
Programmcode. buchinventar.php, buch_insert.php und buch_liste.php
Aus dem HTML-Teil werden nur die Formularfelder mit ihren Inhalten ausgedruckt.
<?php // buchinventar,php
include("connect.inc.php");
$query_rs = "SELECT * FROM buchinv";
$suchtext = "";
$msg = "Alle Datensätze ausgewählt";
$debugMsg = "";
$attribut = "autor";
// insert
if (isset($_POST["insert"]))
{
$gehezu = "buch_insert.php";
header(sprintf("Location: %s", $gehezu));
}
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 74
//delete
if (isset($_POST['delete']))
{
$delId = $_POST['deleteId'];
$deleteSQL = "DELETE FROM buchinv WHERE nr = '$delId';";
$rs = mysql_query($deleteSQL) or die(mysql_error());
$msg = "Datensatz wurde gelöscht";
}
//update
if (isset($_POST['update']))
{
$vAutor = trim($_POST['tAutor']);
$vTitel = trim($_POST['tTitel']);
$vVerlag = trim($_POST['tVerlag']);
$vJahr = trim($_POST['tJahr']);
$vPreis = (double)$_POST['tPreis'];
$vStand = trim($_POST['tStand']);
$updId = trim($_POST['updateId']);
$updateSQL = "UPDATE buchinv SET autor = '$vAutor',titel = '$vTitel',
verlag = '$vVerlag', jahr = '$vJahr', preis = '$vPreis',
standort = '$vStand' WHERE nr = '$updId';";
$rs = mysql_query($updateSQL) or die(mysql_error());
$msg = "Datensatz wurde aktualisiert";
$debugMsg = $updateSQL;
}
// buchliste
if (isset($_POST["liste"]))
{
$gehezu = "buch_liste.php";
header(sprintf("Location: %s", $gehezu));
}
//search
if (isset($_POST["search"]))
{
$attribut = $_POST["aSelect"];
$suchtext = $_POST["tSuchtext"];
if ($suchtext == "")
{
$query_rs = "SELECT * FROM buchinv";
$msg = "Alle Datensätze ausgewählt";
$debugMsg = $query_rs;
}
else
{
$query_rs = "SELECT * FROM buchinv WHERE $attribut = '$suchtext';";
$msg = "Suchen mit leerem Namen klicken, um alle Datensätze auszuwählen.";
$debugMsg = $query_rs;
}
}
else
{
$query_rs = "SELECT * FROM buchinv";
}
?>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 75
<?php
$rs = mysql_query($query_rs) or die(mysql_error());
$row_rs = mysql_fetch_assoc($rs);
$totalRows_rs = mysql_num_rows($rs);
if ($totalRows_rs == 0)
{
$query_rs = "SELECT * FROM buchinv";
$msg = "Keine Datensätze gefunden. Alle Datensätze ausgewählt.";
$debugMsg = $query_rs;
$rs = mysql_query($query_rs) or die(mysql_error());
$row_rs = mysql_fetch_assoc($rs);
$totalRows_rs = mysql_num_rows($rs);
}
?>
<html> (nur Formularelemente ohne Formatierung)
<form name="form1" method="post" action="">
<?php echo $row_rs['nr'];
<input name="tAutor" type="text" value="<?php echo $row_rs['autor']; ?>"
<input name="tTitel" type="text" value="<?php echo $row_rs['titel']; ?>"
<input name="tVerlag" type="text" value="<?php echo $row_rs['verlag']; ?>"
<input name="tJahr" type="text" value="<?php echo $row_rs['jahr']; ?>"
<input name="tPreis" type="text" value="<?php echo $row_rs['preis']; ?>"
<input name="tStand" type="text" value="<?php echo $row_rs['standort'];?>"
<SELECT name = 'aSelect' size = '1'>
<option value = 'autor'>Autor
<option value = 'titel'>Titel
<option value = 'verlag'>Verlag
</SELECT>
<input name="tSuchtext" type="text" size="35" >
<input name="search" type="submit" id="search" value="Suchen">
<input name="insert" type="submit" value=" Datensatz einfügen
">
<input type="hidden" name="deleteId" value="<?php echo $row_rs['nr']; ?>">
<input name="delete" type="submit" value="Datensatz löschen">
<input type="hidden" name="updateId" value="<?php echo $row_rs['nr']; ?>">
<input name="update" type="submit" value="Datensatz aktualisieren">
<input name="liste" type="submit" id="liste" value="Bücherliste">
<p>Anzahl Datensätze: <?php echo $totalRows_rs; ?></p>
<?php
mysql_free_result($rs);
mysql_close();
?>
----------------buch_insert.php---------------------------------------<?php
//Verbindung
include("connect.inc.php");
$msg = "";
$error_msg = "";
$autor = "";
$titel = "";
$verlag = "";
$jahr = "";
$preis = "";
$stand = "";
$antwort = "";
if (isset($_POST["Submit"]))
{
$autor = trim($_POST["tAutor"]);
if (strlen($autor) == 0)
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 76
$error_msg = "Er wurde kein Autor eingegeben. ";
$titel = trim($_POST["tTitel"]);
if (strlen($titel) == 0)
$error_msg .= "Er wurde kein Titel eingegeben. ";
$verlag = trim($_POST["tVerlag"]);
if (strlen($verlag) == 0)
$error_msg .= "Er wurde kein Verlag eingegeben. ";
$jahr = trim($_POST["tJahr"]);
$preis = (double)trim($_POST["tPreis"]);
if (empty($preis))
$error_msg .= "Der Preis ist ungültig. ";
$stand = trim($_POST["tStand"]);
if($error_msg)
{
$antwort = "Ihre Eingabe ist unvollständig: <br> ";
//echo $error_msg;
}
else
{
$eintrag ="INSERT INTO buchinv (autor, titel, verlag, jahr, preis,
standort) VALUES ('$autor', '$titel', '$verlag',
$jahr','$preis','$stand')";
$eintragen = mysql_query($eintrag);
$msg = "Der Datensatz wurde eigetragen.";
$autor = ""; $titel = ""; $verlag = ""; $jahr = ""; $preis = ""; $stand
= "";
}
}
if (isset($_POST["Cancel"]))
{
$gehezu = "buchinventar.php";
header(sprintf("Location: %s", $gehezu));
}
?>
<html>
<body onLoad = "document.form1.tAutor.focus()">
<form name="form1" method="post" action="">
<input name="tAutor" type="text" value="<?php echo $autor; ?>"
<input name="tTitel" type="text" value="<?php echo $titel; ?>"
<input name="tVerlag" type="text" value="<?php echo $verlag; ?>"
<input name="tJahr" type="text" value="<?php echo $jahr; ?>"
<input name="tPreis" type="text" value="<?php echo $preis; ?>"
<input name="tStand" type="text" value="<?php echo $stand; ?>"
<input type="submit" name="Submit" value="Abschicken">
<input type="submit" name="Cancel" value="Abbrechen"></form>
<p><?php echo $antwort; ?></p>
<p><?php echo $error_msg; ?></p>
<p><?php echo $msg; ?></p>
</html>
<?php
mysql_close();
?>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 77
<?php
//buch_liste.php Stellt erfasste Datensätze in einer Liste dar
include("connect.inc.php");
$query_rs = "SELECT * FROM buchinv";
$rs = mysql_query($query_rs) or die(mysql_error());
$row_rs = mysql_fetch_assoc($rs);
$totalRows_rs = mysql_num_rows($rs);
if (isset($_POST["admin"]))
{
$gehezu = "buchinventar.php";
header(sprintf("Location: %s", $gehezu));
}
if (isset($_POST["insert"]))
{
$gehezu = "buch_insert.php";
header(sprintf("Location: %s", $gehezu));
}
?>
<html>
</font><form name="form1" method="post" action="">
<?php echo strftime('%d.%m.%Y') ?>)
<input name="admin" type="submit" value="Administration">
<td width="41%"><input name="insert" type="submit" value="Neuerfassen">
<?php do { ?>
<tr >
<td> <?php echo $row_rs['nr']; ?></td>
<td> <?php echo $row_rs['autor']; ?> </td>
<td> <?php echo $row_rs['titel']; ?> </td>
<td> <?php echo $row_rs['verlag']; ?> </td>
<td> <?php echo $row_rs['jahr']; ?> </td>
<td> <?php echo $row_rs['preis']; ?> </td>
<td> <?php echo $row_rs['standort']; ?> </td>
</tr>
<?php } while ($row_rs = mysql_fetch_assoc($rs)) ; ?>
<p>Anzahl Datensätze: <?php echo $totalRows_rs ?> </p>
</html>
<?php
mysql_free_result($rs);
?>
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 78
9. Gesellschaftliche Auswirkungen von Datenbanken
Unsere Informationsgesellschaft erfordert immer mehr Massnahmen zur Bekämpfung der Computerkriminalität und immer bessere technische Sicherheitsstandards mit Zugriffskontrollsystemen. Da die Datenbanken sehr viele Informationen enthalten, sind sie ein lohnendes Angriffsobjekt. Eine Aufklärung der betroffenen Systembenutzer sowie geeignete DatenschutzRahmenbedingungen sind wichtiger als Strafvorschriften.
9.1 Datensicherheit
Der plötzliche Verlust grossen Datenmengen kann schwerwiegende Konsequenzen haben. Daten eines Unternehmens (Bank, Amtsstelle, Rechenzentrum usw.) müssen vor Verlust, ungewollten Veränderungen, Diebstahl oder Fälschung geschützt werden.
Massnahmen der Datensicherheit:
 Die Computer müssen geschützt werden, damit beim Stromausfall und technischen Mängeln
keine Daten verloren gehen.
 Von Dateien auf externen Datenträgern müssen gesonderte Kopien aufbewahrt werden.
 Die gespeicherten Daten dürfen nicht durch Fehlbedienungen verfälscht werden.
 Die Daten sind vor unberechtigten Zugriffen zu sichern.
 Bei Fremdübertragung müssen schützenswerte Daten zusätzlich verschlüsselt und damit
gegen illegales Abhören gesichert werden.
9.2 Datenschutz
Die wachsende Leistungsfähigkeit der Computer, immer bessere und leistungsfähigere Datenbanksysteme und die weltweite Vernetzung der Datenbanksysteme ermöglichen eine grosse
Zunahme der gespeicherten Daten.
Betrachten wir z. B. ein Cumulus-, oder ein Super Card – Datenbanksystem, in dem sämtliche
Einkäufe der Migros- bzw. Coop-Kunden gespeichert sind: Kundenname, Artikel, Preis, Kaufort
und Kaufdatum. Mit einem einfachen Filter lassen sich verschiedene Informationen herausholen
z.B. "Wer gibt mehr Geld für Kosmetikartikel aus, Frauen oder Männer?" oder "Welche Artikel
werden vor Weihnachten am meisten verkauft?". Es lassen sich aber auch viele personenbezogene Informationen herausholen:
 Kaufgewohnheiten einer bestimmter Person (welche Artikel, welche Menge, wie viele Alko-
holgetränke pro Monat usw.)
 An welchem Ort hat eine bestimmte Person zu einer bestimmten Zeit eingekauft?
Ausserdem gehört zu dieser Datenbank zweifellos eine zweite Tabelle mit Personaldaten wie
Name, Vorname, Strasse, PLZ, Adresse usw. Wenn sich jemand die Wohnungsanschrift einer
Person aus dieser Datenbank verschafft, ist es isoliert kein Problem, aber die grosse Menge der
gespeicherten Personen, die leichte Beschaffung solchen Daten und ihre beliebige Verknüpfbarkeit ändern die Situation. Wenn jemand Adressen von tausend Personen an eine Werbeagentur verkauft wird es problematisch.
Über ähnliche Mengen von Personen-Daten verfügen Online-Shops im Internet, oder Softwarefirmen, die nur mit einer Online Registrierung die Benutzung einer Software erlauben.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 79
Wenn persönliche Daten (schulische, medizinische, militärische, polizeiliche) zum Zwecke der
politischen Überwachung in einer Datenbank gespeichert sind und zu neuen Aussagen verknüpft werden, können viele Personen dadurch betroffen sein.
Der Datenschutz will die Betroffenen davor schützen, dass unnötige, unvollständige oder unrichtige Daten ein falsches Bild über eine Person entstehen lassen. Aus diesem Grund wurde in
verschiedenen Ländern ein Datenschutzgesetz formuliert.
Datenschutzgesetz regelt insbesondere den Umgang mit Personendaten. Unter persönlichen
Daten verstehen wir Informationen, mit denen sich die Identität ermitteln lässt. Also etwa der
Name, die Adresse oder das Telefonnummer.
Besonders schützenswerte Personendaten sind Angaben über
 religiöse, politische und weltanschauliche Ansichten und Betätigung
 der persönliche Zustand (seelisch, geistig, körperlich)
 medizinische Daten
 soziale Fürsorge
 Straftaten usw.
Leider sind die im Datenschutzgesetzt geregelten Massnahmen nicht immer aktuell.
9.3 Verknüpfung von Informationen und neue Risiken
Unter Data-Mining versteht man die automatisierte Suche nach bisher nicht bekannten Zusammenhängen in grossen Datenbeständen. Als Grundlage für die Suche dient das DataWarehouse. Ein Data-Warehouse fasst mit Hilfe von Extraktions- und Konvertierungssoftware
Daten aus verschiedenen Datenbanksystemen in einer einheitlichen Datenbank zusammen, so
dass sämtliche Informationen für "beliebige" Zwecke verknüpfbar sind.
Das Data Warehouse ermöglicht eine neue Betrachtungsweise der Daten. Bisher unbekannte
Zusammenhänge zwischen Einzeldaten können aus der Gesamtheit des Datenbestandes erkannt werden, um z.B. wirtschaftliche Vorteile für eine Organisation zu erzielen. Dabei ist beabsichtigt, dem Manager oder dem Behördenleiter aus der Fülle des Datenmaterials nur die strategisch wichtigen Informationen - möglichst in ansprechender und visuell einprägsamer Form –
darzustellen.
Diese Suchtechniken werden immer häufiger von der Polizei genutzt. Man sucht z.B. einem
Verdächtigen, der einen schwarzen Peugeot 206 fährt. Das Suchen in der Strassenverkehrsamt
Datenbank ergibt mehrere Tausend Peugeot Fahrer. Wenn man aber zusätzlich weiss, dass
sich diese Person in der Schweiz in einen Hotel aufhält, ergibt die Kombination mit den HotelDaten nur einige wenige Personen, die überprüft werden müssen.
Was für die Wirtschaft oder Kriminalistik vorteilhaft ist, führt bei den Personal-Datenbanken zu
Problemen.
Durch die Verknüpfung von Informationen aus verschiedenen Datenbanken lassen sich oft
Schlüsse ziehen, die den Datenschutz verletzen (unzulässige Inferenzen durch zulässige Datenzugriffe).
Arbeitgeber, die sich über den Gesundheitszustand von Bewerbern informieren, Versicherungen, die ihre Prämien an der Fitness ihrer Kunden bemessen, unbeschränkte Verwendung von
Gendatenbanken, dies darf nicht Realität werden.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 80
Anonymisierung
Für die medizinische Forschung bieten grosse Datensammlungen mit einer Vielzahl von Merkmalen zum Zwecke komplexer Auswertungen erhebliche Möglichkeiten.
Zusammenführung von Informationen aus verschiedenen Quellen ist nicht immer erwünscht.
Stellt man sich zum Beispiel Patientendaten in einem Krankenhaus vor, so sind
 für den behandelnden Arzt alle Daten zugänglich
 für einen Forscher sollten nur Diagnose- und Therapiedaten zugänglich sein
Die Datenschutzgesetzgebung fordert das Löschen des Personenbezugs in Datensätzen (Anonymisierung) wo immer möglich. Es muss verhindert werden, dass vertrauliche Informationen
aus zulässigen Zugriffen durch Interferenz hergeleitet werden können.
US-Data-Mining-Pilotprojekt MATRIX
MATRIX steht für "Multistate Anti-Terrorism Information Exchange" und wird von dem PrivatUnternehmen "Seisint Inc. of Boca Raton" im US-Staat Florida entwickelt. Dabei sollen behördliche und kommerzielle Datenbanken miteinander verknüpft und die Ergebnisse sollen in Form
eines Dossiers zu jedem Individuum gebündelt werden. Auf diese Dossiers sollen Strafverfolgungsbehörden der einzelnen, freiwillig der MATRIX angeschlossenen Staaten sowie die Bundesbehörden für ihre detaillierte Suche und Fahndungen zugreifen dürfen. Viel Unmut schafft
auch die Speicherung der Fingerabdrücke und Personaldaten bei den Einreisenden in die USA.
Genetische Informationen in Polizeidatenbanken für erkennungsdienstliche Zwecke
Immer häufiger wird bei der Verfolgung von Straftaten am Tatort oder beim Opfer festgestelltes,
sog. biologisches Material als Spurenmaterial durch die Polizei sichergestellt, mittels DNAAnalyse untersucht und mit anderen DNA-Daten verglichen. Die DNA-Analyse ist zur Standardmethode geworden, um die Herkunft von Spurenmaterial von bestimmten bekannten Personen (Verdächtigen, Opfern, unbeteiligten Dritten) oder die Identität mit anderem Spurenmaterial unbekannter Personen feststellen zu können.
Bezüglich des Aussagegehalts der gespeicherten Daten der Analyseergebnisse ist ein grundsätzlich neuer Aspekt zu berücksichtigen:
Die automatisiert gespeicherten Informationen aus DNA-Merkmalen, die zum Zweck der Identitätsfeststellung erstellt worden sind, ermöglichen derzeit tatsächlich zwar keine über die Identifizierung hinausgehenden Aussagen zur jeweiligen Person oder deren Erbgut. In Einzelfällen
können die analysierten nicht codierenden persönlichkeitsneutralen DNA-Merkmale jedoch mit
codierenden Merkmalen korrespondieren. In Anbetracht der weltweiten intensiven Forschung im
Bereich der Genom-Analyse ist es nicht ausgeschlossen, dass künftig auch auf der Basis der
Untersuchung von bisher als nicht codierend angesehenen Merkmalen konkrete Aussagen über
genetische Dispositionen der betroffenen Personen mit inhaltlichem Informationswert gemacht
werden können. Dieses Risiko ist deshalb nicht zu vernachlässigen, weil gegenwärtig weltweit
mit erheblichem Aufwand die Entschlüsselung des gesamten menschlichen Genoms vorangetrieben wird.
datenbanken.docx
01.01.2013/ J. Arnold
Datenbanken
Seite 81
10. Literatur:
Dässler Rolf: MySQL, bhv-Verlag 2001
Aegidius Plüss: Java exemplarisch, Oldenbourg Verlag, 2004
Bornträger Alex: MySQL, Franzis'Verlag, 2003
Franke Jochen: Dynamische Webseiten mit PHP4, Franzis' Verlag, 2003
Heuer Andreas: Datenbanken kompakt, mitp-Verlag, 2003
Wille Stephan: Go to Java Server Pages, Addison-Wesley, 2003
Urban Georg: Access 2003, SPC TEIA-Verlag, 2003
Brochhagen, Schäffer: Das grosse Buch Dreamweaver MX, Databecker, 2004
Sauer Hermann: Relationale Datenbanken, Addison-Wessley, 2003
Spona Helma: Datenbankprogrammierung mit MySQL und PHP4, bhv 2003
datenbanken.docx
01.01.2013/ J. Arnold
Herunterladen