MYSQL Datenbankserver und
SQL (Structured Query Language)
Einführung in MySQL und PHP Seite 1 von 37 Andreas Renner – BG. Gallus
MYSQL Datenbankserver &
SQL (Structured Query Language)
Eine Einführung von Andreas Renner
BG. Gallus 2003
Inhaltsverzeichnis
1 Voraussetzungen: ............................................................................................................................. 3
2 Lernziele: ........................................................................................................................................... 3
3 Überblick und Erklärungen ................................................................................................................ 3
4 Wie gelangt man in mein lokales MySQL Datenbanksystem der PHPDEV
Entwicklungsumgebung? .................................................................................................................. 5
5 Protokollierung .................................................................................................................................. 5
6 Einfache SQL Abfragen einer Tabelle nach Datenstrukturen (show) ............................................... 6
7 Abfragen von Tabellen nach Daten (select) ..................................................................................... 7
8 Einfügen von Daten (insert) .............................................................................................................. 9
9 Änderung der Daten (update) ........................................................................................................... 9
10 Löschen von Daten (delete) .............................................................................................................. 9
11 Änderungen an der Datenbankstruktur – Datenbanken, Tabellen, Felder ... (alter, create, drop): .. 9
12 Datenhandling über externe Textdateien. ....................................................................................... 10
13 Ausführen von Berechnungen und Funktionen in Abfragen (group, min, max, avg ...) .................. 11
14 Rechte und Zugriffssteuerung auf eine MySql Datenbankserver und Datenbank – Priveleges
(grant - revoke)................................................................................................................................ 12
15 Aufgabe: .......................................................................................................................................... 15
16 MySQL Serververwaltung mit PHPMyAdmin .................................................................................. 16
17 Access Control mit htaccess Files oder PHPMYSQL Authentifizierung ......................................... 17
18 Zugriff auf eine MySql Datenbank mit PHP .................................................................................... 22
Einführung in MySQL und PHP Seite 2 von 37 Andreas Renner – BG. Gallus
1 Voraussetzungen:
Diese kurze Einführung in MySql setzt voraus, dass
1.1 die Entwicklungsumgebung „PHPDEV“ von http://www.firepages.com.au/ auf ihrem Windows
System installiert ist,
1.2 Starten sie die PHPDEV Umgebung (Apache Webserver, PHP, MySQL) mit dem Batch: 2K-NT-
XP-phpdev_start.bat im Verzeichnis c:/phpdev. Ich habe den Start- und Stop Batch
(phpdev_start.bat und phpdev_stop.bat) etwas erweitert. Sie finden diese Batches im
Verzeichnis ..\ MySql_Kurs.
1.3 Suchen sie in C:\winnt\php.ini und setzten sie den Eintrag register_globals=on.
1.4
1.5 Folgende Dateiein und Verzeichnisse
brauchen sie für diesen Kurs:
2 Lernziele:
Es soll möglichst schnell ein Einblick in MYSQL vermittelt werden. Zum weiteren Studium bieten
sich die Manuals und diverse Tutorials im Internet an.
2.1 Verwaltung von MySQL Datenbanksystemen über Eingabeaufforderung (Telnet ..)
2.2 SQL Befehle zu einfachen Datenbankrecherchen
2.3 SQL Befehle zu einfachen Datenbankveränderungen
2.4 SQL Befehle zur Erstellung und Veränderung von Datenbankstrukturen
2.5 SQL Befehle zur Rechteverwaltung
2.6 PHPMyAdmin: PHP-basiertes Verwaltungstool für MySQL Datenbanken
3 Überblick und Erklärungen
3.1 SQL (ausgesprochen "sequel")
steht für Structured Query Language und wird als Schnittstelle zu relationalen Datenbanken
benutzt. SQL ist nach dem ANSI (American National Standards Institute) Standard genormt und
damit auf viele RDBMS (relational database management systems) anwendbar, z.B. Oracle,
Sybase, Microsoft SQL Server, Access, Ingres, etc. SQL Anweisungen werden sowohl zur
Daten-Anfrage als auch zur Daten-Definition verwendet. Obwohl die meisten Systeme eine
gemeinsame Standardmenge von Anfrage-/Definitionsbefehlen verwenden, haben sie meist
auch herstellerspezifische (proprietary) Erweiterungen. Trotz alledem kann man mit den
typischen und einfachen SQL - Befehlen "Select", "Insert", "Update", "Delete", "Create", and
"Drop" und daraus konstruierten Kombinationen mächtige allgemein verwendbare Operationen
in Datenbankenausführen
3.2 MySQL
MySQL ist eine echte Multi-User, Multi-Treaded SQL Datenbank und wird von allen großen
Providern oder auch Suchmaschinenbetreibern eingesetzt. MySQL ist eine CLient/Server
Implentierung, die aus einem Server-Dämon mysqld und vielen Client Programmen, sowie
Bibliotheken für PERL, PHP/3, PHP/4 sowie ASP besteht.
SQL ist eine standardisierte Datenbanksprache, die das Speichern, Updaten und den Zugriff auf
Informationen erleichtert. Beispielsweise kann man Produktinformationen eines Kunden auf
einem WWW-Server speichern und abrufen. MySQL ist äußerst schnell und flexibel genug, um
sogar Bilder und Log-Dateien darin abzulegen. In der Praxis ist MySQL sehr viel schneller, als
z.B. ORACLE oder INFORMIX.
Die wichtigsten Eigenschaften von MySQL sind Geschwindigkeit, Stabilität und einfache
Bedienbarkeit. MySQL wurde ursprünglich entwickelt, weil auf TCX (dem Server der Entwickler)
ein SQL Server benötigt wurde, der sehr große Datenbanken handeln konnte, und zwar um eine
Größenordnung schneller, als die Datenbankhersteller damals liefern konnten. MySQL ist nun
nun seit 1996 auf vielen Tausend Sites im Internet und Intranet im Einsatz und erfreut sich hier
wachsender Beliebtheit. MySQL ist bei vielen tausend Unternehmen im täglichen Einsatz, von
denen über 500 mehr als 7 Millionen Einträge bzw mehr als 100 Gigabyte an Daten mangagen.
Auf der Site http://www.rent-a-database.de ist eine Auszug einer Referenzliste zu finden.
Einführung in MySQL und PHP Seite 3 von 37 Andreas Renner – BG. Gallus
MySQL ist geradezu prädestiniert zur Beschleunigung bestehender ACCESS Datenbanken.
Diese Kombination ermöglicht es, mit nur kleinen Änderungen in ACCESS die
Datenbankabfragen um Faktor 3-100 zu beschleunigen.
3.3 Steuerung von MySql
Ein DBS kann auf drei Arten gesteuert werden: Entweder dialogorientiert, im Batch-Betrieb oder
durch andere Programme. Dialogorientiert bedeutet, dass man am Bildschirm seine Befehle
eingibt und innerhalb von Sekunden das Ergebnis oder die Fehlermeldung erhält. Das ganze ist
vergleichbar mit der Konsole beim Betriebssystem. In beiden Fällen gibt es einen Prompt, an
dem man seine Befehle eingibt und im selben Fenster erscheint dann die Ausgabe. Über den
MySQL-Prompt hat man natürlich die meisten Möglichkeiten, weil man jeden Befehl verwenden
kann. Häufig ist aber auch ein wenig Unterstützung durch ein Programm praktisch, das z.B. die
Tabellenstruktur anzeigt oder beim Ändern die alten Werte als Vorbelegung nimmt etc. Ein sehr
schönes Programm dazu ist phpMyAdmin. Mit phpMyAdmin werden wir dialogorientiert arbeiten.
Alle Befehle, die hier direkt eingegeben werden, können aber auch in eine Text-Datei
geschrieben werden, die dann dialogorientiert abgearbeitet wird. Das nennt man dann Batch-
Betrieb. Sehr empfehlenswert ist dies z.B. für die Erstellung von Tabellen. Dann kann man
nämlich ohne großen Aufwand dieselbe Tabellenstruktur in verschiedenen DBs verwenden. Bei
der Benutzung durch andere Programme merkt der Benutzer nicht, dass eine oder welche
Datenbank im Hintergrund arbeitet. So benutzen z.B. alle Suchmaschinen im Internet (Google,
AltaVista, Yahoo) in irgendeiner Form eine Datenbank, um die Informationen zu speichern. Als
normaler Nutzer sieht man aber nur die Suchmaske und bekommt dann die Ergebnisse schön
formatiert angezeigt. Es muss dann ein Programm geben, das die eingegebene Anfrage an die
Datenbank weiterreicht und dann die Ergebnisse formatiert ausgibt. Dieses Programm kann im
Prinzip in jeder beliebigen Sprache geschrieben werden. Häufig wird dafür PHP verwendet, was
weiter unten noch beschrieben wird.
Um mit dem DBMS zu reden, muss das Programm mysql von einem Rechner, von dem aus
man Zugriff auf den Rechner mit dem DBMS hat, gestartet werden. Viele Provider erlauben dies
leider aus Sicherheitsgründen nicht, so dass es empfehlenswert ist, sich zu Hause ein DBMS zu
installieren. Die Aufrufsyntax lautet:
mysql -p -u
Für Passwort, Benutzername und DB-Name sind natürlich die entsprechenden Werte
einzutragen (ohne die spitzen Klammern!). Diese bekommen sie vom Provider, der ihnen die
Datenbank zur Verfügung stellt, bzw., im Falle einer eigenen DB, geben sie sich selbst die
Daten.
mysql -u -p
Enter password: ********
Wie sie sehen, wird in diesem Fall das Passwort explizit abgefragt. Diese Methode ist der
Möglichkeit, das Passwort hinter -p anzugeben, aus zwei Gründen vorzuziehen: Zum einen
erscheint dann das Passwort weder (unter Unix/Linux) in der .bash_history noch im Klartext auf
dem Bildschirm und zum anderen hat man dann auch nicht das Problem, darauf achten zu
müssen, dass zwischen -p und dem Passwort kein Leerzeichen stehen darf, weil nach einem
solchen je nach Reihenfolge der Parameter der Datenbankname erwartet wird... Wenn sie
keinen DB-Namen angeben, bekommen sie zwar auch den mysql-Prompt, können dann aber
einige Befehle nicht nutzen, weil sie mit keiner Datenbank verbunden werden. Dann müssen sie
noch mit Hilfe von USE die Datenbank angeben. Es werden mindestens zwei
Accounts für dieselbe DB erstellt. Einen, für den sowohl Lese- als auch Schreibzugriffe erlaubt
sind, und einen anderen, der nur lesend zugreifen darf.
Wenn das alles geklappt hat, kommt folgende Ausgabe (oder ähnlich):
Welcome to the MySQL monitor. Commands end with ; or \\g.
Your MySQL connection id is 1561 to server version: 3.22.32
Type 'help' for help.
mysql>
Immer dann, wenn in der letzten Zeile ein mysql> steht, können sie ihre Befehle eingeben. Die
Groß-/Kleinschreibung ist bei den Befehlen egal, bei den Tabellen- und Spaltennamen
(Attribute) sowie den eigentlichen Werten dagegen natürlich nicht!
Einführung in MySQL und PHP Seite 4 von 37 Andreas Renner – BG. Gallus
path=%path%;C:\phpdev\mysql\bin
4 Wie gelangt man in mein lokales MySQL cd C:\phpdev\apache
start apache -k start
Datenbanksystem der PHPDEV cd C:\phpdev\
Entwicklungsumgebung? start apachemonitor.exe
4.1 Start der PHPDEV Umgebung cd C:\phpdev\mysql\bin
start mysqld-nt.exe --standalone
4.2 Start der Eingabeaufforderung start http://localhost/
4.3 Path Verweis ins Verzeichnis bin von MySQL cmd
path c:\phpdeb\mysql\bin exit
Diesen Vorgang können sie auch automatisieren, indem sie die
Startdatei (2K-NT-XP-phpdev_start.bat) erweitern:
4.4 mysql (–u Benutzername –p Passwort
falls nötig)
Bei neuinstallierten Systemen ist der
„Datenbankchef“ root mit leerem Passwort oder
Passwort root . Zusätzlich hat jeder am
Localhost Vollzugriff auf das MySQL System.
Eine Sicherheitslücke, die wir später schließen werden.
4.5 Jetzt müssen SQL Befehle mit abschließendem ; (Strichpunkt) eingegeben werden
4.6 Mit quit gelange ich wieder aus der MySQL Umgebung.
4.7 Hilfe zum MySql Kommando
mysql> \h;
MySQL commands:
Note that all text commands must be first on line and end with ';'
help (\h) Display this help.
? (\?) Synonym for `help'.
clear (\c) Clear command.
connect (\r) Reconnect to the server. Optional arguments are db and host.
ego (\G) Send command to mysql server, display result vertically.
exit (\q) Exit mysql. Same as quit.
go (\g) Send command to mysql server.
notee (\t) Don't write into outfile.
print (\p) Print current command.
quit (\q) Quit mysql.
rehash (\#) Rebuild completion hash.
source (\.) Execute a SQL script file. Takes a file name as an argument.
status (\s) Get status information from the server.
tee (\T) Set outfile [to_outfile]. Append everything into given outfile.
use (\u) Use another database. Takes database name as argument.
5 Protokollierung
Es ist sehr hilfreich, alle SQL Ein- und Ausgaben in eine Datei protokollieren zu lassen.
mysql> tee c:\temp\prtokol1.log
Logging to file 'c:\temp\protokol1.log'
Einführung in MySQL und PHP Seite 5 von 37 Andreas Renner – BG. Gallus
6 Einfache SQL Abfragen einer Tabelle nach Datenstrukturen (show)
Abfrage des MySQL Datenbankservers nach Datenbanken, Tabellen und Feldern
6.1 Anzeigen der Datenbanken auf einem MySQL Server
mysql> show databases;
+-----------------+
| Database |
+-----------------+
| central_user_db |
| invision |
| mysql |
| phpwebsite |
| test |
| training |
+-----------------+
7 rows in set (0.00 sec)
6.2 Öffnen und verwenden einer Datenbank:
Die Datenbank samp_db besteht bereits und liegt im Ordner ..\mysql\data\sap_db
Wir wollen sie jetzt öffnen und die Tabellenstruktur ausgeben.
mysql> use training;
Database changed
6.3 Anzeigen der Tabellen einer Datenbank
mysql> show tables;
+--------------------+
| Tables_in_training |
+--------------------+
| personal |
| schulung |
| teilnehmer |
| veranstalter |
+--------------------+
4 rows in set (0.00 sec)
6.4 Anzeigen der Felder einer Tabelle
mysql> show fields from personal;
+----------------+-----------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------------+-----------------+------+-----+---------+----------------+
| personalnummer | int(5) unsigned | | PRI | NULL | auto_increment |
| vorname | varchar(30) | | | | |
| nachname | varchar(30) | | | | |
| strasse | varchar(30) | YES | | NULL | |
| plz | varchar(8) | YES | | NULL | |
| ort | varchar(30) | YES | | NULL | |
| geburt | date | YES | | NULL | |
| geschlecht | enum('W','M') | | | W | |
| gehalt | decimal(6,2) | YES | | NULL | |
+----------------+-----------------+------+-----+---------+----------------+
9 rows in set (0.01 sec)
Einführung in MySQL und PHP Seite 6 von 37 Andreas Renner – BG. Gallus
7 Abfragen von Tabellen nach Daten (select)
7.1 Abfrage aller Datensätzen in einer Tabelle
mysql> select * from personal;
+----------------+-------------+----------+---------------------+-------+-----------------+------------+------------+---------+
| personalnummer | vorname | nachname | strasse | plz | ort | geburt | geschlecht | gehalt |
+----------------+-------------+----------+---------------------+-------+-----------------+------------+------------+---------+
| 1008 | Eike | Taro | Musterstr. 6 | 09999 | Musterdorf | 1947-09-10 | W | 5100.00 |
| 1002 | Kai | Müller | Hallesche Str. 16 | 04838 | Eilenburg | 1951-12-28 | M | 3400.00 |
| 1112 | Hannes | Heik | Musterstr. 145 | 09999 | Musterdorf | 1961-02-06 | M | 5600.00 |
| 1429 | Torsten | Mieder | Hauptstrasse 16 | 04838 | Laussig | 1971-05-15 | M | 5400.00 |
| 1016 | Ulrich | Müller | Weide Str. 2 a | 04838 | Hohenpriessnitz | 1951-01-02 | M | 8999.00 |
| 1430 | Christine | Schwarz | Musterstr. 8 | 09999 | Musterdorf | 1948-04-24 | W | 5420.00 |
to be continued
7.2 Abfrage aller Datensätzen in einer Tabelle nach einem Kriterium
Es sollen nur weibliche Mitarbeiterinnen abgefragt werden.
mysql> select * from personal where geschlecht = 'W';
+----------------+-----------+----------+-------------------+-------+-------------+------------+------------+---------+
| personalnummer | vorname | nachname | strasse | plz | ort | geburt | geschlecht | gehalt |
+----------------+-----------+----------+-------------------+-------+-------------+------------+------------+---------+
| 1008 | Eike | Taro | Musterstr. 6 | 09999 | Musterdorf | 1947-09-10 | W | 5100.00 |
| 1430 | Christine | Schwarz | Musterstr. 8 | 09999 | Musterdorf | 1948-04-24 | W | 5420.00 |
| 1439 | Elfi | Kaufmann | Brandstrasse 15 e | 04827 | Gerichshain | 1966-01-29 | W | 3900.00 |
| 1437 | Christa | Renner | Weidenstrasse 26 | 25469 | Halstenbek | 1932-12-27 | W | 3900.00 |
| 1431 | Birgit | Gemse | Bauernkoppel 39 | 22393 | Hamburg | 1958-01-13 | W | 1200.00 |
| 1433 | Silvia | Munter | Treppe 7 | 22587 | Hamburg | 1952-04-28 | W | 4555.00 |
| 1100 | Kerstin | Gans | Hauptstr.10 | 04838 | Moertitz | 1961-03-19 | W | 6000.00 |
+----------------+-----------+----------+-------------------+-------+-------------+------------+------------+---------+
rows in set (0.00 sec)
7.3 Abfrage aller Datensätzen in einer Tabelle nach einem Kriterium und
Anzeige von bestimmten Feldern
Diesmal sollen von Mitarbeiterinnen nur der Vorname und der Nachname angezeigt werden.
mysql> select vorname,nachname from personal where geschlecht = 'W';
+-----------+----------+
| vorname | nachname |
+-----------+----------+
| Eike | Taro |
| Christine | Schwarz |
| Elfi | Kaufmann |
| Christa | Renner |
| Birgit | Gemse |
| Silvia | Munter |
| Kerstin | Gans |
+-----------+----------+
7 rows in set (0.00 sec)
7.4 Abfragen basierend auf mehreren Kriterien
Wir interessieren uns für Mitarbeiterinnen die vor 1960 geboren sind. Angezeigt werden
Personalnummer, Vorname, Nachname und Geburtsdatum.
mysql> select personalnummer,vorname,nachname,geburt from personal where
geschlecht = 'W' and geburt select personalnummer,vorname,nachname,geburt from personal where
geschlecht = 'W' and geburt show fields from teilnehmer;
+----------------+-----------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------------+-----------------+------+-----+---------+----------------+
| laufende_nr | int(5) unsigned | | PRI | NULL | auto_increment |
| personalnummer | int(5) unsigned | | | 0 | |
| besucht | char(1) | | | 0 | |
+----------------+-----------------+------+-----+---------+----------------+
3 rows in set (0.00 sec)
Wir suchen nun nach Personen die eine Schulung besucht haben:
mysql> select vorname, nachname from teilnehmer, personal where
teilnehmer.personalnummer=personal.personalnummer;
+-----------+----------+
| vorname | nachname |
+-----------+----------+
| Kai | Müller |
| Karsten | Müller |
| Jürgen | Marx |
| Bernd | Jach |
| Kai | Müller |
| Kerstin | Gans |
| Christine | Schwarz |
| Manfred | Stach |
+-----------+----------+
8 rows in set (0.01 sec)
Einführung in MySQL und PHP Seite 8 von 37 Andreas Renner – BG. Gallus
8 Einfügen von Daten (insert)
mysql> insert into personal (nachname,vorname,geschlecht) values
("Renner","Andreas","M");
Query OK, 1 row affected (0.02 sec)
mysql> select * from personal;
+----------------+-------------+----------+---------------------+-------+-----------------+------------+------------+---------+
| personalnummer | vorname | nachname | strasse | plz | ort | geburt | geschlecht | gehalt |
+----------------+-------------+----------+---------------------+-------+-----------------+------------+------------+---------+
| 1008 | Eike | Taro | Musterstr. 6 | 09999 | Musterdorf | 1947-09-10 | W | 5100.00 |
| 1005 | Ede | Pfau | Nicoleiplatz 2 | 04232 | Leipzig | 1952-08-02 | M | 4500.00 |
| 1100 | Kerstin | Gans | Hauptstr.10 | 04838 | Moertitz | 1961-03-19 | W | 6000.00 |
| 1438 | Manfred | Stach | Gerbergasse 7 | 04105 | Leipzig | 1946-09-26 | M | 3500.00 |
| 1114 | Karsten | Müller | Musterstr. 3 | 09999 | Musterdorf | 1963-07-12 | M | 4900.00 |
| 1017 | Klaus | Ecke | Schulze-Str. 11 | 4808 | Wurzen | 1955-04-13 | M | 2555.00 |
| 1440 | Andreas | Renner | NULL | NULL | NULL | NULL | M | NULL |
+----------------+-------------+----------+---------------------+-------+-----------------+------------+------------+---------+
24 rows in set (0.00 sec)
9 Änderung der Daten (update)
mysql> update personal set geschlecht = "W" where nachname = "Renner" and
vorname = "Andreas";
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> select * from personal;
+----------------+-------------+----------+---------------------+-------+-----------------+------------+------------+---------+
| personalnummer | vorname | nachname | strasse | plz | ort | geburt | geschlecht | gehalt |
+----------------+-------------+----------+---------------------+-------+-----------------+------------+------------+---------+
| 1008 | Eike | Taro | Musterstr. 6 | 09999 | Musterdorf | 1947-09-10 | W | 5100.00 |
| 1017 | Klaus | Ecke | Schulze-Str. 11 | 4808 | Wurzen | 1955-04-13 | M | 2555.00 |
| 1440 | Andreas | Renner | NULL | NULL | NULL | NULL | W | NULL |
+----------------+-------------+----------+---------------------+-------+-----------------+------------+------------+---------+
24 rows in set (0.00 sec)
10 Löschen von Daten (delete)
mysql> delete from personal where nachname = "Renner" and vorname ="Andreas";
Query OK, 1 row affected (0.00 sec)
11 Änderungen an der Datenbankstruktur – Datenbanken, Tabellen, Felder ...
(alter, create, drop):
11.1 Ändern von Strukturen: ALTER
Unsere Trainingsdatenbank hat ein paar gravierende Mängel. So können wir zB. nicht festhalten
welche Schulung ein Mitarbeiter besucht hat, da uns ein entsprechendes Feld in der Tabelle
teilnehmer fehlt.
Wir wollen auch die Leistung der Mitarbeiter im Abschusstest der Schulung festhalten und fügen
ein Feld punkte ein.
mysql> use training;
Database changed
mysql> show fields from teilnehmer;
+----------------+-----------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------------+-----------------+------+-----+---------+----------------+
| laufende_nr | int(5) unsigned | | PRI | NULL | auto_increment |
| personalnummer | int(5) unsigned | | | 0 | |
| besucht | char(1) | | | 0 | |
+----------------+-----------------+------+-----+---------+----------------+
Fügen wir zu diesem Zweck ein Feld schulung_nr ein. Das Feld soll ganze Zahlen aufnehmen, 5
Felder breit sein, kein Vorzeichen haben und keinen Null Wert enthalten. Der Standardwert ist
somit 0 (bei Character Feldern wäre er „“ – Leerstring)
mysql> ALTER TABLE `teilnehmer` ADD `schulung_nr` INT( 5 ) UNSIGNED NOT NULL;
mysql> ALTER TABLE `teilnehmer` add `punkte` INT( 5 ) UNSIGNED NOT NULL;
Der Variablentyp INT hat 4 Byte. SMALLINT mit 2 Byte würde auch reichen. Also machen wir eine
Änderung am Feld Punkte:
Einführung in MySQL und PHP Seite 9 von 37 Andreas Renner – BG. Gallus
mysql> ALTER TABLE `teilnehmer` CHANGE `punkte` `punkte` SMALLINT( 5 )
UNSIGNED DEFAULT '0' NOT NULL
Und so schaut das Ganze dann aus.
mysql> show fields from teilnehmer; mysql> show fields from teilnehmer;
+----------------+----------------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------------+----------------------+------+-----+---------+----------------+
| laufende_nr | int(5) unsigned | | PRI | NULL | auto_increment |
| personalnummer | int(5) unsigned | | | 0 | |
| besucht | char(1) | | | 0 | |
| schulung_nr | int(5) unsigned | | | 0 | |
| punkte | smallint(5) unsigned | | | 0 | |
+----------------+----------------------+------+-----+---------+----------------+
11.2 Anlegen neuer Datenbanken oder Tabellen: CREATE
Wir wollen in einer Tabelle die Absenzen unserer Mitarbeiter mit Begründung erfassen.
CREATE TABLE `absenz` (
`absenz_nr` INT( 5 ) UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`absenz_grund` VARCHAR( 20 ) NOT NULL ,
`absenz_zeit` SMALLINT( 4 ) UNSIGNED NOT NULL
);
11.3 Löschen von Datenbanken, Tabellen und Feldern: DROP
Sie sind der Meinung, dass dieses Vorgehen arbeitsrechtlich nicht gedeckt ist?! Also löschen wir
den absenz_grund aus der Tabelle
ALTER TABLE `absenz` DROP `absenz_grund`;
Eigentlich könnten wir auch die ganze Tabelle absenz löschen.
DROP TABLE `absenz`;
Was würde dieser Befehl anrichten?
DROP DATABASE `mysql`;
12 Datenhandling über externe Textdateien.
Größere Mengen an Daten können auch über externe Textdateiein eingegeben, verändert oder
gelöscht werden. Geben wir Daten in unsere Tabelle teilnehmer ein. Bitte beachten sie, dass es
in MySQL keine referentielle Integrität gibt. Es kann also nicht automatisch verhindert werden,
dass sie beim Feld personal_nr Nummern eingeben, die in der Tabelle personal nicht
vorkommen. Zuerst müssen wir aber noch ein paar Schulungen eingeben.
INSERT INTO `schulung` ( `laufende_nr` , `schulungsbezeichnung` ,
`kursbeginn` , `kursende` , `kurskosten` , `veranstalter_nr` )
VALUES (
'', 'Textverarbeitung', '2001-01-01', '2001-01-10', '100', '1'
'', 'Excel', '2002-02-02', '2002-02-20', '200', '2'
'', 'Access', '2003-03-03', '2003-03-30', '300', '3'
);
Die Tabelle teilnehmer füllen wir jetzt mit Daten aus
einer externen Textdatei – teilnehmer.txt. Die Datei
finden sie im MySQL _Kurs Verzeichnis. Stellen sie
diese gleich ins aktuelle Verzeichnis
(c:\phpdev\mysql\bin\).
Die einzelnen Felder sind mit Tabstops getrennt, die
Zeilen mit return abgeschlossen und am Beginn jeder
Zeile ist ein „leerer“ Tabstop. Dieses erste Feld wird vom
System mit autoincrement belegt.
In der SQL Anweisung LOAD DATA LOCAL INFILE
kann man diverse Einstellungen treffen zu Separateren, Zeilendeliminatoren usw vornehmen.
Man könnte auch ganze SQL Anweisungen in Batch-Files ausführen lassen. Darauf gehe ich
hier nicht ein.
mysql> LOAD DATA LOCAL INFILE 'teilnehmer.txt' INTO TABLE `teilnehmer`;
Query OK, 12 rows affected (0.00 sec)
Records: 12 Deleted: 0 Skipped: 0 Warnings: 12
mysql> select * from teilnehmer;
Einführung in MySQL und PHP Seite 10 von 37 Andreas Renner – BG. Gallus
+-------------+----------------+---------+-------------+--------+
| laufende_nr | personalnummer | besucht | schulung_nr | punkte |
+-------------+----------------+---------+-------------+--------+
| 1017 | 1010 | j | 1 | 1 |
| 1016 | 1008 | j | 3 | 240 |
| 1015 | 1008 | j | 2 | 160 |
| 1014 | 1008 | j | 1 | 80 |
| 1013 | 1005 | j | 3 | 150 |
| 1012 | 1005 | j | 2 | 100 |
| 1011 | 1002 | j | 3 | 30 |
| 1010 | 1002 | j | 2 | 20 |
| 1009 | 1005 | j | 2 | 50 |
| 1008 | 1002 | j | 1 | 10 |
| 1018 | 1010 | j | 2 | 2 |
| 1019 | 1010 | j | 3 | 3 |
+-------------+----------------+---------+-------------+--------+
13 Ausführen von Berechnungen und Funktionen in Abfragen (group, min,
max, avg ...)
Es kommt oft vor, dass man sich in Abfragen auch Daten auswerten lassen will. Dafür gibt es
vorgefertigte Funktionen oder man kann selbst welche definieren. Wir wollen uns
MitarbeiterInnen, die Schulungen besucht haben, auflisten und dazu interessante Details zu
ihrer Performance in den Tests.
mysql> select nachname,vorname from personal,teilnehmer where
personal.personalnummer = teilnehmer.personalnummer;
+----------+---------+
| nachname | vorname |
+----------+---------+
| Marx | J³rgen |
| Taro | Eike |
| Taro | Eike |
| Taro | Eike |
| Pfau | Ede |
| Pfau | Ede |
| M³ller | Kai |
| M³ller | Kai |
| Pfau | Ede |
| M³ller | Kai |
| Marx | J³rgen |
| Marx | J³rgen |
+----------+---------+
12 rows in set (0.00 sec)
Mit der group Funktion werden die Datensätze gruppiert und nicht immer wiederholt.
mysql> select nachname,vorname from personal,teilnehmer where
personal.personalnummer = teilnehmer.personalnummer group
by personal.personalnummer;
+----------+---------+
| nachname | vorname |
+----------+---------+
| M³ller | Kai |
| Pfau | Ede |
| Taro | Eike |
| Marx | J³rgen |
Jetzt wollen wir noch das Minimum, das Maximum und die Durchschnittspunktezahl ausgeben.
mysql> select nachname,vorname, min(punkte) as Minimum, max(punkte) as
Maximum, avg(punkte) as Durchschitt from personal,teilnehmer where
personal.personalnummer = teilnehmer.personalnummer group by
personal.personalnummer;
+----------+---------+---------+---------+-------------+
| nachname | vorname | Minimum | Maximum | Durchschitt |
+----------+---------+---------+---------+-------------+
Einführung in MySQL und PHP Seite 11 von 37 Andreas Renner – BG. Gallus
| M³ller | Kai | 10 | 30 | 20.0000 |
| Pfau | Ede | 50 | 150 | 100.0000 |
| Taro | Eike | 80 | 240 | 160.0000 |
| Marx | J³rgen | 1 | 3 | 2.0000 |
+----------+---------+---------+---------+-------------+
14 Rechte und Zugriffssteuerung auf eine MySql Datenbankserver und
Datenbank – Priveleges (grant - revoke)
Derzeit kann jeder Änderungen an allen unseren Datenbanken vornehmen. Für die Verwendung
in Internet ist das natürlich völlig inakzeptabel. Wenn wir uns an einem MySQL Datenbankserver
anmelden, weiß der Server von wo wir kommen (Host) und wer wir sind (Username Passwort).
Auf jedem MySQL Datenbankserver existiert eine Datenbank mysql mit folgenden Tabellen:
Unsere effektiven Rechte ergeben sich für den Server aus folgenden Aspekten:
Woher kommst du?
Wer bist du?
Was willst du?
14.1 mysql: die zentrale Verwaltungsdatenbank zur Zugriffssteuerung
mysql> show databases;
+-----------------+
| Database |
+-----------------+
| central_user_db |
| invision |
| mysql Zentrale Datenbank zur Verwaltung des MySQL Servers
| phpwebsite |
| samp_db |
| test |
| training |
+-----------------+
mysql> use mysql;
14.2 Ebenen der Zugriffssteuerung
Jede Tabelle in mysql stellt eine Ebene in der Zugriffssteuerung dar.
mysql> show tables;
+-----------------+
| Tables_in_mysql |
+-----------------+
| columns_priv | Rechte in Spalten (Felder) einzelner Datenbanken
| db | Rechte in einzelnen Datenbanken
| func | Benutzerdefinierte Funktionen
| host | Rechte in einzelnen Datenbanken von gewissen Clientrechnern aus
| tables_priv | Rechte in Tabellen einzelner Datenbanken
| user | Verzeichnis aller Benutzer und deren Rechte auf den MySql Server, abhängig
+-----------------+ von welchem Clientrechner sie auf das Datenbanksystem zugreifen.
14.3 Rechte (Priveleges)
Oberste Ebene ist die User Datenbank von MySQL selbst. Wir verbinden uns zuerst mit dieser
Tabelle User:
mysql> show fields from user;
+-----------------+-----------------+------+-----+---------+----------------+
| Field | Type | Erklärung |
+-----------------+-----------------+------+-----+---------+----------------+
| Host | char(60) binary |Von welchem Rechner kommen wir (%) |
| User | char(16) binary |Wer sind wir |
| Password | char(16) binary |Was ist unser Passwort |
| Select_priv | enum('N','Y') |Abfragerecht (Daten lesen) |
| Insert_priv | enum('N','Y') |Einfügerecht (neue Daten schreiben) |
| Update_priv | enum('N','Y') |Ändernrecht (vorhandene Daten ändern) |
Einführung in MySQL und PHP Seite 12 von 37 Andreas Renner – BG. Gallus
| Delete_priv | enum('N','Y') |Löschrecht (vorhandene Daten löschen) |
| Create_priv | enum('N','Y') |Datenbankstrukturen erstellen .........|
| Drop_priv | enum('N','Y') |Datenbankstrukturen löschen |
| Reload_priv | enum('N','Y') |Datenbanksystem neu laden |
| Shutdown_priv | enum('N','Y') |Datenbanksystem herunterfahren |
| Process_priv | enum('N','Y') | |
| File_priv | enum('N','Y') | |
| Grant_priv | enum('N','Y') |Rechte vergeben |
| References_priv | enum('N','Y') | |
| Index_priv | enum('N','Y') |Index erstellen |
| Alter_priv | enum('N','Y') |Ändern der Datenstruktur |
+-----------------+-----------------+------+-----+---------+----------------+
mysql> select * from user;
+-----------+------+----------+-------------+-------------+-------------+-------------+-------------+
| Host | User | Password | Select_priv | Insert_priv | Update_priv | Delete_priv | Create_priv |
+-----------+------+----------+-------------+-------------+-------------+-------------+-------------+
| localhost | root | | Y | Y | Y | Y | Y |
| % | root | | Y | Y | Y | Y | Y |
| localhost | | | Y | Y | Y | Y | Y |
| % | | | N | N | N | N | N |
+-----------+------+----------+-------------+-------------+-------------+-------------+-------------+
Diese Liste ist nach links unvollständig!
14.4 Benutzer
Root: Der Benutzer Root ist immer der Chef, der Administrator der Datenbank. Er hat kein
Passwort, was in einem produktiven System eine fatale Sicherheitslücke ist.
%: Der Benutzer % ist jeder. Hier hat jeder vom lokalen Computer aus alle Rechte. Darum
müssen wir im Augenblick auch kein Passwort eingeben – eine ebenfalls große
Sicherheitslücke.
14.5 Benutzer anlegen (grant)
Änderungen in Tabellen, die Privilegien verwalten, müssen mit grant und revoke durchgeführt
werden.
Dem User Paul wird auf der Maschine auf der DB-Server läuft, Rechte und Passwort für die Datenbank
training gegeben. Dem Paul werden mit All Rechte auf alle Attribute der Datenbank gegeben. Paul wird
in der Tabelle user angelegt und das Passwort verschlüsselt. Paul hat in der Tabelle user keine Rechte.
Dazu wechseln wir zuerst in die Datenbank training:
mysql> use training
Database changed
Jetzt geben wir dem Paul alle Rechte auf alle Tabellen der Datenbank.
mysql> grant all on * to Paul@localhost;
Query OK, 0 rows affected (0.00 sec)
Mit grant all on personal,schulung to Paul@localhost bekäme Paul nur Rechte in diesen beiden
Tabellen.
Query OK, 0 rows affected (0.01 sec)
mysql> select * from user;
+-----------+------+------------------+-------------+-------------+-------------+------------
| Host | User | Password | Select_priv | Insert_priv | Update_priv | Delete_priv | Create_priv |
+-----------+------+------------------+-------------+-------------+-------------+-------------+-------------+
| localhost | root | | Y | Y | Y | Y | Y |
| % | root | | Y | Y | Y | Y | Y |
| localhost | | | Y | Y | Y | Y | Y |
| % | | | N | N | N | N | N |
| localhost | Paul | 428567f408994404 | N | N | N | N | N |
+-----------+------+------------------+-------------+-------------+-------------+-------------+-------------+
5 rows in set (0.00 sec)
Über die konkreten Rechte des Benutzers Paul in der Datenbank training erfahren wir mehr in
der Tabelle tables_priv .
mysql> select * from tables_priv;
+-----------+-------+------+------------+----------------+----------------+--------------------------
| Host | Db | User | Table_name | Grantor | Timestamp | Table_priv
+-----------+-------+------+------------+----------------+----------------+-------------------------+
| localhost | mysql | Paul | training | ODBC@localhost | 20030724123447 |Select,Insert,Update, ...
+-----------+-------+------+------------+----------------+----------------+--------------------------
Einführung in MySQL und PHP Seite 13 von 37 Andreas Renner – BG. Gallus
Schauen wir uns jetzt die Veränderungen in der Verwaltungsdatenbank mysql an
mysql> use mysql;
Database changed
Diese Verwaltungsinformationen stehen jetzt in der Tabelle db. Wenn ich spezielle Privilegien für die
Tabellen definieren würde, fände ich sie in der Tabelle tables_priv.
mysql> select * from db;
+-----------+----------+------+-------------+-------------+-------------+-
| Host | Db | User | Select_priv | Insert_priv | Update_priv |
+-----------+----------+------+-------------+-------------+-------------+-
| % | test% | | Y | Y | Y |Y
| localhost | training | Paul | Y | Y | Y |Y
+-------------+-------------+-------------+-----------+------------+------
Wenn sich Paul nun an der Datenbank Training anmelden möchte, gibt er folgendes ein:
Ausloggen vom DB-Server
mysql> quit
Bye
Einloggen als Paul am lokalen Computer.
C:\phpdev\mysql\bin>mysql -u Paul -p training
Enter password: ******
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 123 to server version: 4.0.0-alpha-nt
14.6 Benutzer / Rechte löschen (revoke)
So löschen wir Pauls Rechte in der Datenbank training.
mysql> use training
Database changed
mysql> revoke all on * from Paul@localhost;
So schmeißen wir Paul aus der Benutzerdatenbank hinaus.
mysql> use mysql
Database changed
mysql> DELETE FROM `user` WHERE `Host` = 'localhost' AND `User` =
'Paul';
mysql> grant all on training to Paul@localhost identified by "secret";
Ich hoffe sie haben das Grundlegende der MySQL Datenbankverwaltung verstanden. Leichter
geht’s mit dem PHP basierten Verwaltungstool PHPMyadmin.
Einführung in MySQL und PHP Seite 14 von 37 Andreas Renner – BG. Gallus
15 Aufgabe:
Erstellen Sie die Datenbank samp_db mit einer Tabelle president. Die dazugehörenden Felder,
Daten und SQL Anweisungen finden sie in Ordner ..\samp_db\president. Das Ganze sollte dann
etwa so ausschauen:
+------------+---------------+--------+---------------------+-------+------------+------------+
| last_name | first_name | suffix | city | state | birth | death |
+------------+---------------+--------+---------------------+-------+------------+------------+
| Washington | George | NULL | Wakefield | VA | 1732-02-22 | 1799-12-14 |
| Adams | John | NULL | Braintree | MA | 1735-10-30 | 1826-07-04 |
| Jefferson | Thomas | NULL | Albemarle County | VA | 1743-04-13 | 1826-07-04 |
...
| Bush | George W. | NULL | Milton | MA | 1924-06-24 | NULL |
| Clinton | William J. | NULL | Hope | AK | 1946-08-19 | NULL |
+------------+---------------+--------+---------------------+-------+------------+------------+
41 rows in set (0.00 sec)
Erstellen sie eine Abfrage, welche die Anzahl der Präsidenten von jedem Bundesstaat ausgibt
und das Ganze nach der Häufigkeit ordnet.
mysql> select state, count(state) as Anzahl from president group by state order by Anzahl desc;
+-------+--------+
| state | Anzahl |
+-------+--------+
| VA | 8 |
| OH | 7 |
| NY | 4 |
| MA | 4 |
| NC | 2 |
| VT | 2 |
| TX | 2 |
| NH | 1 |
| PA | 1 |
| KY | 1 |
| NJ | 1 |
| IA | 1 |
| MO | 1 |
| CA | 1 |
| NE | 1 |
| GA | 1 |
| IL | 1 |
| AK | 1 |
| SC | 1 |
+-------+--------+
19 rows in set (0.00 sec)
Erstellen sie die Tabelle members. Sie enthält die Mitgliederliste des Präsidentenquizes. Daten
und SQL Anweisungen finden sie in Ordner ..\samp_db\ .
Einführung in MySQL und PHP Seite 15 von 37 Andreas Renner – BG. Gallus
16 MySQL Serververwaltung mit PHPMyAdmin
phpMyAdmin ist ein komplett in PHP geschriebenes Programm zur Verwaltung von mySQL
Datenbanken über ein Web – Interface. Praktische Bedeutung hat dies vor allem dann, wenn man bei
einem Provider etwas Speicherplatz mit einer Datenbank (sogenannter virtueller Server) bucht, jedoch
keinen direkten Zugriff auf die Datenbank hat. Gerade in der heutigen Zeit kommt hinzu, dass viele
sich eine eigene Seite einrichten, wohl aber nicht wissen, wie man mysql bedient. Es fehlen selbst bei
denjenigen manchmal die grundlegenden Kenntnisse, die einen eigenen Server haben. Abhilfe schafft
hier phpMyAdmin. Es kommt in einer übersichtlichen Benutzeroberfläche und bietet den beliebten
„One-Klick“ Komfort zum Administrieren der jeweiligen mySQL Datenbank.
Da PHPMyAdmin weitgehend selbsterklärend ist, machen wir uns gleich an unsere Aufgaben.
16.1 Aufgaben:
16.1.1 Mit Hilfe von PHPMyAdmin legen wir in der samp_db folgende Tabellen an
student
Felder:
name VARCHAR(20) NOT NULL,
sex ENUM('F','M') NOT NULL,
student_id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY
Daten: \MySQL_Kurs\samp_db\student.txt
absence
Felder:
student_id INT UNSIGNED NOT NULL,
date DATE NOT NULL,
PRIMARY KEY (student_id, date)
Daten: \MySQL_Kurs\samp_db\.absence.txt
event
Einführung in MySQL und PHP Seite 16 von 37 Andreas Renner – BG. Gallus
Felder:
date DATE NOT NULL,
type ENUM('T','Q') NOT NULL,
event_id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY
Daten: \MySQL_Kurs\samp_db\.event.txt
score
Felder:
student_id INT UNSIGNED NOT NULL,
event_id INT UNSIGNED NOT NULL,
score INT NOT NULL,
PRIMARY KEY (event_id, student_id)
Daten: \MySQL_Kurs\samp_db\.score.txt
16.1.2 Zugriffsrechte auf samp_db und seine Tabellen
Geben sie dem Benutzer root ein komplexes Passwort. Root kann sich nur lokal
anmelden.
Legen sie einen Benutzer gast an. Dieser hat von überall nur Leserechten in der
Datenbank samp_db und ihren Tabellen.
Legen sie sich selbst als Benutzer an. Sie haben von überall alle Rechte in der
Datenbank samp_db und ihren Tabellen.
16.1.3 Erstellen sie Abfragen
Studenten mit einem Score über 80 sollen absteigend nach ihrem Score aufgelistet
werden.
Studenten mit Absenzen sollen mit ihrem Score aufgelistet werden. Sortieren sie
diese aufsteigend nach ihrem Score.
17 Access Control mit htaccess Files oder PHPMYSQL Authentifizierung
Man kann den Zugang zu einem beliebigen Verzeichnis und seinen Unterverzeichnissen mit
httaccess kontrollieren, wie in Punkt 17.1 beschrieben. Hier übernimmt der Apache Webserver
die Zugriffssteuerung.
In unserem speziellen Fall soll aber der Zugang zur MySQL Datenbank mittels PHPMyAdmin
eingeschränkt werden. Hierzu gibt es spezielle Konfigurationslösungen für das Zusammenspiel
zwischen PHPMyadmin und MySQL, wobei MySQL die Benutzerauthentifizierung und
Zugangssteuerung übernimmt. Diese Methoden ist den httaccess Files überlegen. Mehr dazu
im Punkt 17.2.
17.1 Access Control des PHPMYADMIN Directories mit htaccess Files
Der Apache Webserver bietet eine Möglichkeit der Authentication, Authorization, and Access
Control mittels htaccess Files. Falls aktiviert, wird beim Zugriff auf jedes Directory und
Subdirectory des Webservers ein htaccess File gesucht und ausgewertet, was die Performance
des Webservers belastet. Die Access Control Mechanismen des Apache Webservers sind auch
weniger zuverlässig als die Zugriffssteuerungen, die im jeweiligen Serverbetriebssystem
implementiert sind. Für Sicherheitseinstellungen auf Betriebssystemebene bedarf es aber
administrativer Rechte über das gesamte Serversystem.
Diese Ausführungen hier beschränken sich auf Basic Authentification. Weitere rigidere
Authentifizierungsmechanismen (Digest Authentification) finden sie im Manual, das bei der
Apache – Installation mitgeliefert wird (../apache/manual/howto/auth.html).
17.1.1 Die Konfigurationsschritte im Überblick : Der Schutz von Inhalt mit „Basic
authentication“
Mit folgenden 2 bzw 3 Schritten können sie eine Webressource schützen.
Erstellen eines Passwort Files
Einführung in MySQL und PHP Seite 17 von 37 Andreas Renner – BG. Gallus
Apache Webserver für die „basic authentication“ und dieses Passwort File konfigurieren
Optional: Erstellen eines Benutzergruppenfiles
Access Control in der Datei htpd.conf, der zentralen Konfigurationsdatei des Apache
Kommen wir jetzt zu den Details:
17.1.2 Erstellen eines Passwort Files
Das Passwort File enthält die Benutzernamen und die verschlüsselten Passwörter. Es muss
außerhalb des „Document Directories“ (www, wwwroot ...) erstellt werden, um Hackern den
Zugriff zu erschweren. Hat ein Hacker den Benutzernamen und den Passwort-Hash, kann der
das Passwort mit geeigneten Tools (Lought Crack) einfach cracken. Wir legen es ins
Verzeichnis .. /apache/passwd. Das Programm zum erstellen der Benutzer finden sie in ..
/apache/bin/htpasswd.
C:\phpdev\Apache\bin>htpasswd -c C:/phpdev/apache/passwd/passwords
andreas
Automatically using MD5 format on Windows.
New password: *******
Re-type new password: *******
Adding password for user andreas
Editieren sie das neue File
../apache/passwd/passwords
Der Schalter –c wird nur beim ersten Erstellen der
Datei passwords verwendet. Weitere Benutzer
müssen ohne den Schalter –c hinzugefügt werden.
Fügen sie den Benutzer root hinzu und editieren sie
die Datei erneut.
Schützen sie diese Datei zusätzlich mit Dateisystemrechten des Betriebssystems. Der
Administrator sollte Vollzugriff haben, der Webserver braucht nur Leserechte. Alle anderen geht
die Datei passwords nichts an. Files, die mit .ht beginnen, werden vom Apache standardmäßig
versteckt. Das wäre eine zusätzliche Sicherheit.
17.1.3 Apache Webserver für die „basic authentication“ und dieses Passwort File
konfigurieren
Jetzt müssen wir dem Apache noch erklären, dass er diese Zugangsinformationen verwenden
sollt. Die notwendigen Anweisungen schreibt man in ein File namens
.htaccess und kopieren sie .htaccess ins Verzeichnis ../phpmyadmin/.htaccess
.
In Windows konnte ich das File nur in der Eingabeaufforderung mit führendem (Punkt)
benennen
oder in das Hauptkonfigurationsfile des Apache, dem httpd.conf, in eine
Sektion.
17.1.4 Optional: Erstellen eines Benutzergruppenfiles
Wenn der Zugang mehreren (wechselnden) Benutzern gewährt werden soll, ist es einfacher
den Zugang auf Gruppenebene zu regeln. Nur Mitlieder einer Gruppe kommen dann rein.
Erstellen sie zuerst ein File das die Gruppen definiert. In diesem File – nennen wir es
groups – definieren wir einfach wer dazugehört.
mysql_admins: root andreas
Kopieren sie das File in unseren Passwortbereich: c:/phpdev/apache/passwd/groups
Anweisungen in der .htaccess
AuthType Basic
AuthName "MySQL Konfigurationsbereich"
AuthUserFile c:/phpdev/apache/passwd/passwords
AuthGroupFile c:/phpdev/apache/passwd/groups
Require group mysql_admins
Einführung in MySQL und PHP Seite 18 von 37 Andreas Renner – BG. Gallus
17.1.5 Access Control in der Datei htpd.conf, der zentralen Konfigurationsdatei des
Apache
Im folgenden Abschnitt, der ein virtuelles Verzeichnis zu phpmyadmin definiert, sind
Änderungen vorzunehmen –siehe Fettdruck. AllowOverride All erlaubt den Anweisungen in
.htaccess alle anderen zu überschreiben.
Alias /phpmyadmin/ "C:/phpdev/phpmyadmin/"
Options Indexes FollowSymLinks MultiViews
AllowOverride All
Order allow,deny
Allow from localhost 127.0.0.1
DirectoryIndex index.php
Optional: Diese Access Control Einstellung würde Verbindungen von allen Hosts verbieten. Nur
vom Rechner hostname.example.com und 194.183.140.110 kann man sich verbinden.
Order Deny,Allow
Deny from all
Allow from hostname.example.com
Allow from 194.183.140.110
Ich musste meinen Apache mehrmals stoppen und starten bis die Zugangskontrolle funktionierte.
17.2 PHPMYSQL Authentifizierung
Befolgend sie bitte folgende Schritte aus der PHPMyAdmin Dokumentation:
C:\phpdev\phpmyadmin\ Documentation.html
Sie müssen sich über den Authentifizierungstyp klar werden
Sie müssen in der MySQL Datenbank einen Controluser einrichten
Sie müssen Einträge in die Datei C:\phpdev\phpmyadmin\config.inc.php
17.2.1 Using authentication modes:
Http and cookie authentication modes are recommended in a multi-user environment where
you want to give users access to their own database and don't want them to play around with
others. Nevertheless be aware that MS Internet Explorer seems to be really buggy about
cookies, at least till version 6. And php 4.1.1 is also a bit buggy in this area!
Http and cookie authentication modes are more secure: the MySQL password does not need to
be set in the phpMyAdmin configuration file (except for the "controluser" -see the
Configuration section- further down). However, keep in mind that the password travels in
plain text, unless you are using the https protocol. In cookie mode, we send the password in a
temporary cookie, so most browsers should not store the password in their cookie file.
Whether config or cookie or http authentication should be used for this server.
'config' authentication ($auth_type = 'config') is the plain old way: username and password
are stored in config.inc.php3.
Please see the install section on "Using authentication modes" for more information.
$cfg['Servers'][$i]['user'] string
$cfg['Servers'][$i]['password'] string
The user/password-pair which phpMyAdmin will use to connect to this MySQL-server. This
user/password pair is not needed when http or cookie authentication is used, and should be
empty.
'http' authentication mode:
Was called 'advanced' in versions before 2.2.3.
Introduced in 1.3.0, it uses Basic HTTP authentication method and allows you to login as any
valid MySQL user.
Is only supported with PHP running as an Apache module, not with cgi.
'cookie' authentication mode:
Einführung in MySQL und PHP Seite 19 von 37 Andreas Renner – BG. Gallus
You can use this method as a replacement for the http authentication (for example, if you're
running IIS).
Obviously, the user must enable cookies in the browser.
With this mode, the use can truly logout of phpMyAdmin and login back with the same
username.
'config' authentication mode:
This mode is the less secure one because it requires you to fill the $cfg['Servers'][$i]['user'] and
$cfg['Servers'][$i]['password'] fields.
But you don't need to setup a "controluser" here: using the $cfg['Servers'][$i]['only_db'] might be
enough.
In the ISP FAQ section, there is an entry explaining how to protect your configuration file.
For additional security in this mode, you may wish to consider the Host authentication
$cfg['Servers'][$i]['AllowDeny']['order'] and $cfg['Servers'][$i]['AllowDeny']['rules'] configuration
directives.
17.2.2 Der Controluser und seine Rechte in der MySql Datenbank
For 'http' and 'cookie' modes, phpMyAdmin needs a controluser that has only the SELECT
privilege on the mysql.user (all columns except "Password"), mysql.db (all columns) &
mysql.tables_priv (all columns except "Grantor" & "Timestamp") tables.
GRANT USAGE ON mysql.* TO 'pma'@'localhost' IDENTIFIED BY 'pmapass';
GRANT SELECT (Host, User, Select_priv, Insert_priv, Update_priv, Delete_priv, Create_priv,
Drop_priv, Reload_priv, Shutdown_priv, Process_priv, File_priv, Grant_priv, References_priv,
Index_priv, Alter_priv) ON mysql.user TO 'pma'@'localhost';
GRANT SELECT ON mysql.db TO 'pma'@'localhost';
GRANT SELECT (Host, Db, User, Table_name, Table_priv, Column_priv) ON mysql.tables_priv
TO 'pma'@'localhost';
... and if you want to use the many new relation and bookmark features:
GRANT SELECT, INSERT, UPDATE, DELETE ON TO 'pma'@'localhost';
(this of course requires you to have a special DB for phpMyAdmin, the contents will be
explained later)
Then each of the true users should be granted of a set of privileges on a set of particular
databases but shouldn't have any global privileges. For example, to grant the user real_user
with all privileges on the database user_base:
GRANT ALL PRIVILEGES ON user_base.* TO 'real_user'@localhost
IDENTIFIED BY 'real_password';
What the user may now do is controlled entirely by the MySQL user management system.
With http or cookie auth mode, you don't need to fill the user/password fields inside the
$cfg['Servers'] array.
17.2.3 Einträge in das File config.inc.php
You must specify the details for the controluser in the config.inc.php3 file under the
$cfg['Servers'][$i]['controluser']& $cfg['Servers'][$i]['controlpass'] settings.
This example assumes you want to use pma as the controluser and pmapass as the
controlpass, but this is only an example: use something else in your file:
$cfg['Servers'][$i]['controluser'] pma
$cfg['Servers'][$i]['controlpass'] pmapass
When using http or cookie authentication modes (or 'config' authentication mode since
phpMyAdmin 2.2.1), you need to supply the details of a MySQL ControlUser.
Die Einträge in das File config.inc.php schauen bei mir so aus:
* Server(s) configuration
Einführung in MySQL und PHP Seite 20 von 37 Andreas Renner – BG. Gallus
*/
$i = 0;
// The $cfg['Servers'] array starts with $cfg['Servers'][1]. Do not use $cfg['Servers'][0].
// You can disable a server config entry by setting host to ''.
$i++;
$cfg['Servers'][$i]['host'] = 'localhost'; // MySQL hostname
$cfg['Servers'][$i]['port'] = ''; // MySQL port - leave blank for default port
$cfg['Servers'][$i]['socket'] = ''; // Path to the socket - leave blank for default socket
$cfg['Servers'][$i]['connect_type'] = 'tcp'; // How to connect to MySQL server ('tcp' or
'socket')
$cfg['Servers'][$i]['controluser'] = 'pma'; // MySQL control user settings
// (this user must have read-only
$cfg['Servers'][$i]['controlpass'] = 'pmapass'; // access to the "mysql/user"
// and "mysql/db"
tables)
$cfg['Servers'][$i]['auth_type'] = 'http'; //
Authentication method (config, http or cookie based)?
$cfg['Servers'][$i]['user'] = ''; // MySQL user
$cfg['Servers'][$i]['password'] = ''; // MySQL
password (only needed
// with 'config'
auth_type)
17.2.4 Weitere Sicherheitseinstellungen
Ich legen einen Benutzer susi mit „root-Rechten“ an.
„susi“ erhält ein Passwort , das über die Funktion
„Password“ verschlüsselt werden muss. Bei mir
funktionierte die Verschlüsselung mit anderem wie
MD5 nicht. „susi“ hat auch alle Rechte auf die
Datenbank mysql und ist somit ein globaler
Datenbank-Chef.
Den Benutzer „root“ spendiere ich ein Passwort!
Alle anderen MySQL Benutzer kriegen nur Rechte auf
ihre
speziellen Datenbanken (mysql.db),
oder nur gewisse Tabellen dieser
Datenbanken (mysql.tables_priv),
oder nur gewisse Felder
(mysql.columns_priv) dieser Tabellen.
Dabei lege ich für jede Datenbank einen Benutzer an,
der Dinge verändern kann (andreas) und eine Benutzer,
der nur lesen/auswählen (select) kann (jeder). Diese
Benutzer haben in der Datenbank mysql.user keine
Rechte.
Ich hoffe dieser Einstieg in MySQL und PHPMyAdmin
war nicht zu zäh. Sollten sie noch etwas Energie in
Reserve haben, ackern wir den Zugriff auf MySql
Datenbanken mittels PHP durch.
Einführung in MySQL und PHP Seite 21 von 37 Andreas Renner – BG. Gallus
18 Zugriff auf eine MySql Datenbank mit PHP
18.1 Ablauf einer MySql Datenbankabfrage im Internet
Werfen wir eine kurzen Blick auf ein paar Kommunikationsschemata, um die Abläufe zwischen
Browser, Apache und MySQL Datenbank besser zu verstehen.
Browser Apache Datenbank
Webserver -server
MySQL
In vielen Fällen ist beides auf einem Rechner. Die Server könnten auch
getrennte Rechner sein.
Der Apache Server meldet sich beim MySQL Server als Client an.
Damit meldet er sich am localhost an.
Im Netz könnte ein Datenbankserver: db.bg-gallus.ac.at heißen.
Webanfrage ohne Datenbankzugriff
Browser sendet Anfrage an Webserver Apache
Browser
HTML
Seite Browser schickt
HTML-Seite
Webanfrage mit PHP Code ohne MySQL Datenbankzugriff
Browser sendet Anfrage an
Webserver mit Get URL.PHP Apche
Browser
PHP-
HTML Datei
Seite
PHP-Interpreter
erzeugt HTML
Code
Einführung in MySQL und PHP Seite 22 von 37 Andreas Renner – BG. Gallus
Webanfrage mit PHP Code mit MySQL Datenbankzugriff
Browser sendet Anfrage an
Webserver mit Get URL.PHP
Apche MySQL
Browser Datenbank
PHP-
Datei
HTML
Seite
PHP-Interpreter übersetz
Code und stellt eine SQL
Anfrage an die MySQL
Datenbank, die
Abfrageergebnisse zur
verfügung stellt.
PHP-Interpreter erstellt aus den PHP
Anweisungen und SQL
Abfrageergebnissen HTML Code,
der vom Apache an den Client
zurückgegeben wird.
Einführung in MySQL und PHP Seite 23 von 37 Andreas Renner – BG. Gallus
18.2 Übungen zu Abfragen von Datenbanken mit PHP
Wir werden unser nächsten Schritte anhand kleiner Übungsbeispiele machen. Viele Erklärungen
stecken in Form von Kommentaren direkt im Code.
Einzeiliger Kommentar:
US Presidenten Quiz
Willkommen auf der US Presidenten
Quiz Webseite.
Die Liste hat im Augenblick " . $row[0] . "
Mitglieder.\n";
mysql_free_result ($result);
?>
Einführung in MySQL und PHP Seite 25 von 37 Andreas Renner – BG. Gallus
18.2.2 Übung 2: Errorhandling beim Öffnen von Datenbanken
Funktion: die
void die(string message)
Mit die() kann man ein laufendes Skript abbrechen und eine eigene Fehlermeldung (message)
an den Browser senden. Diese Funktion wird oftmals genutzt, um zu überprüfen, ob eine Datei
geöffnet werden konnte oder eine Verbindung zu einer Datenbank aufgenommen wurde. Eine
Rückkehr zur Skriptausführung ist nach dem Aufruf von die() nicht mehr möglich
Errorhandling: Im Beispiel zuvor wurde in Fehlerfall das Script verlassen mit DIE wird eine
Meldung ausgegeben.
Aufgabe: Verändern sie die Übung 18.2.2 entsprechend und erzeugen sie gezielt einen Fehler
$link=@mysql_pconnect("localhost","jeder","jeder")
or die("Kann den Datenbankserver nicht erreichen");
mysql_select_db("samp_db")
or die("Kann die Datenbank nicht auswählen");
$result=mysql_query("select count(*) from member")
or die ("Kann die Abfrage nicht ausführen");
18.2.3 Übung 3: Ausgabe der Daten in Tabellen
Aufgabenstellung: Die Mitglieder unseres Präsidentenquizes sollen tabellarisch ausgegeben
werden.
Die Funktion printf()
Mit printf() kann man Parameter (args) nach einem bestimmten Muster (format) formatieren und
ausgeben lassen. Dabei beschreibt das Muster genau, wo und wie die Parameter zu
formatieren sind.
Mögliche Formatierungsangaben:
% - Legt die zu formatierende Stelle fest.
b - Der Wert wird als Integer interpretiert und binär ausgegeben.
c - Der Wert wird als Integer interpretiert und als ASCII-Zeichen ausgegeben.
d - Der Wert wird als Integer interpretiert und als Dezimalzahl ausgegeben.
f - Der Wert wird als Double interpretiert und als Fließkommazahl ausgegeben.
o- Der Wert wird als Integer interpretiert und als Oktalzahl ausgegeben.
s - Der Wert wird als String interpretiert und als String ausgegeben.
x - Der Wert wird als Integer interpretiert und als Hexadezimalwert in
Kleinbuchstaben ausgegeben.
X - Der Wert wird als Integer interpretiert und als Hexadezimalwert in
Großbuchstaben ausgegeben.
Die Funktion htmlspecialchars()
Mit htmlspecialchars() werden bestimmte Sonderzeichen in den dafür vorgesehenen HTML-
Code umgewandelt. Der zweite Parameter (quote_style) ist optional und erst ab der Version
3.0.17 bzw. 4.0.3 verfügbar. Dieser bewirkt, dass Anführungszeichen mit berücksichtigt werden.
Standardmäßig ist der Wert ENT_COMPAT aktiviert. Falls Sie eine vollständige Umwandlung
der HTML- Zeichen benötigen, so nutzen Sie die Funktion htmlentities().
Die Funktion mysql_num_fields()
Mit mysql_num_fields() kann man sich anhand einer Ergebnis-Kennung die Anzahl der Felder
eines Ergebnisses zurückgeben lassen.
Einführung in MySQL und PHP Seite 26 von 37 Andreas Renner – BG. Gallus
US Presidenten Quiz Mitglieder Liste
US Presidenten Quiz Mitglieder Liste
\n");
/* Schleife mit Abbruchbedingung Solange es Resultate bei der Abfrage
gibt.*/
while ($row = mysql_fetch_row ($result))
{
/* Tabelle wird mit PHP erzeugt. „\n“ ist ein Zeilenumbruch.*/
print ("\n");
for ($i=0; $i%s \n", htmlspecialchars ($row[$i]));
}
print ("\n");
}
print ("\n");
mysql_free_result ($result);
?>
Einführung in MySQL und PHP Seite 27 von 37 Andreas Renner – BG. Gallus
18.2.4 Übung 4: Datenbankabfrage über selbstdefinierte Funktionen
Wir werden für folgende wiederkehrende Aufgaben eigene Funktionen schreiben um in Zukunft
effizienter zu arbeiten. Diese Funktionen können in einer Datei zu einer Programmbibliothek
zusammengefasst werden, die wir mit dem include Befehl in jedes PHP Programm einbinden
können.
Verbindung zum Datenbank-Server
Öffnen der Datenbank
Ausführen von Abfragen
Ausgabe des Abfrageergebnisses in Tabellenform
\n");
while ($lrow = mysql_fetch_row ($lresult)){
print ("\n");
for ($i=0; $i%s \n", htmlspecialchars ($lrow[$i]));
}
print ("\n");
}
print ("\n");
}
?>
US Presidenten Quiz Mitglieder Liste
US Presidenten Quiz Mitglieder Liste
Einführung in MySQL und PHP Seite 28 von 37 Andreas Renner – BG. Gallus
18.2.5 Übung 5: Datenabfrage über HTML-Formular:
Im folgenden Beispiel werden wir in unserer Mitglieder Tabelle gezielt nach Mitgliedern suchen.
Dies erfordert eine Benutzerinteraktion über ein Formular: form_get_table.html
Indieses Formular geben wir einen Nachnamen ein, schicken es ab und erhalten die Angaben zu
dieser Person. Die Formulardaten werden über ein PHP-Script result_get_table.php
ausgewertet und angezeigt. Dabei wird die SQL Wildcard % und der Vergleichsoperator like
eingesetzt.
Alle Formularfelder des Formulars müssen mit der „name“ Eigenschaft benannt werden. Der
Inhalt der Formulardaten wird mit der Methode „GET“ oder „POST“ übergeben. Bei Get stehen
der Inhalt der Varialen dann sichtbar in der URL – auch Passwörter. Die Variablen können in PHP
mit $ und ihrem Namen ausgegeben werden.
Der Formulareintrag schaut so aus:
In PHP greife ich auf die Formularfeldinhalte einfach über Variablen zu. Der Feldname wird in
PHP zur Variablen.
echo $nachname
Das funktioniert nur, wenn in der Datei php.ini der Eintrag register_globals auf On gesetzt ist.
Aus Sicherheitsgründen ist ab PHP 4.2 register_globals=Off
Ich kann auf diese Variablen aber auch mit
echo $http_POST[nachname] oder $_POST[nachname] beziehungsweise
echo $http_GET[nachname] oder $_GET[nachname] zugreifen.
form_get_table.html
US Presidenten Quiz Abrage der
Tabelle member
US Presidenten Quiz: Suche nach Mitgliedern
Nachname:
result_get_table.php
Auswertung: US
Presidenten Quiz
Abrage der Tabelle
member
\n");
while($lrow=mysql_fetch_row($lresult)){
print("");
for($i=0;$i%s \n", htmlspecialchars
($lrow[$i]));
}
print("\n");
}
print("\n");
}
?>
US Presidenten Quiz Abfrageergebnisse
Presidenten Quiz Webseite Abfrageergebnisse.
Einführung in MySQL und PHP Seite 30 von 37 Andreas Renner – BG. Gallus
18.2.6 Include Dateien
Teile oder ganze PHP Programme, aber vor
;;;;;;;;;;;;;;;;;;;;;;;;;
; Paths and Directories ; allem Funktionen können in eigenen
;;;;;;;;;;;;;;;;;;;;;;;;; Dateien abgelegt werden und können dort
von diversen Scripts als
; UNIX: "/path1:/path2" Programmbibliotheken verwendet werden.
;include_path = ".:/php/includes"
; Vor allem Code mit Passwörtern im
; Windows: "\path1;\path2" Reintext, wie bei Verbindungen zum Datenbankserver, sollte in
include_path = Include Dateien gespeichert werden. In der PHP.INI kann der
".;C:/phpdev/php/includes;C:/phpdev/php/class" Pfad zu dem „Includes Verzeichnis“ definiert werden. In unserem
Fall ist das C:/phpdev/php/includes. Das ist der Standardpfad, den die PHP-Funktion
include(„beispiel.php“) verwendet.
Im Apache Webserver könnte auch ein Directory Alias zu einem Verzeichnis oberhalb des htdoc,
www, oder wwwroot Verzeichnisses führen. Diese Verzeichnisse kann man dann effizient mit den
Betriebssystemrechten schützen und somit die Sicherheit erhöhen.
include(„samp_db.inc“);
Der include-Befehl hat zur Folge, dass vom PHP-Parsing-Modus in den HTML-Modus geschaltet
und die angegebene Datei eingelesen und ausgewertet wird. Ist innerhalb der zu inkludierenden
Datei PHP-Code, so muss dieser in gültigen PHP-Start- ()
eingebunden werden.
Aufgabe:
Kopieren sie alle PHP Funktionen von result_get_table.php aus Übung 5 in eine Datei
namens samp_db.inc.
\n");
while($lrow=mysql_fetch_row($lresult)){
print("");
for($i=0;$i%s \n", htmlspecialchars
($lrow[$i]));
}
print("\n");
}
print("\n");
}
?>
Löschen sie diesen Teil aus der Datei result_get_table.php und includieren sie ihn mit:
Einführung in MySQL und PHP Seite 31 von 37 Andreas Renner – BG. Gallus
18.2.7 Übung 7: Abrage über Menüs:
Um die Benutzerfreundlichkeit zu erhöhen, bieten wir dem User ein Auswahlformular an, das ihm
die Abfragedaten vorgibt. Dazu erstellen wir im ersten Schritt im Formular ein Auswahlfenster für
die Datensätze (Select Feld). Das müssen wir wiederum mit Daten aus der Datenbank füttern.
form_menu.html
Menüauswahl
Menüauswahl mit Select Feldern
eins
zwei
drei
vier
fünf
result_menu.php
Menüauswahl Ergebnis
Das Ergebnis der Menüauswahl
Im nächsten Schritt füttern wir die Formularauswahl mit
Werten aus der Datenbank.
form_get_table_select.php
");
while($lrow=mysql_fetch_row($lresult)){
printf("%s\n",$lrow[0],$lrow[0]);
}
print("");
}
?>
Select Menu aus DB füllen
Select Menu aus der Datenbank mit den Nachnamen der Mitglieder
füllen
result_get_table.php
");
while($lrow=mysql_fetch_row($lresult)){
printf("%s\n",$lrow[0],$lrow[0]);
}
print("");
}
?>
Select Menu aus DB füllen
Select Menu aus der Datenbank mit den Nachnamen der Mitglieder
füllen
18.2.8 Auswahl der Bundesstaaten und Anzeige der Präsidenten!
Wir wollen nun aus der Tabelle presidents einen
Bundesstaat auswählen. Das machen wir in
form_president.php. In einem Auswahlfeld (select)
werden alle Bundesstaaten zur Auswahl aufgelistet. In
Klammern steht die Anzahl der Präsidenten des
jeweiligen Bundesstaates.
Als Ergebnis werden in result_president.php alle
Präsidenten aus diesem Bundesstaat aufgelistet. Wie
zuvor brauchen wir im Suchformular wie auch auf der
Ergebnisseite SQL Abfragen.
Die function error($line,$file,$string,$error="") gibt
eine detailiertere Fehlermeldung zurück. Dazu setzen
wir die PHP Funktion mysql_error() und Zong
Konstanten wie __Line__ ein. Zong ist ein
Erweiterungsmodul für PHP und im Lieferumfang von
PHP 4++ mit dabei.
form_president.php
Fehler in Zeile ".$line." in ".$file." ";
$fehler .= "" . $string . ""; if($error)
Einführung in MySQL und PHP Seite 34 von 37 Andreas Renner – BG. Gallus
$fehler .= "MySQL-Error: ". $error;
die($fehler);
}
function samp_db_pconnect(){
$llink=mysql_pconnect("localhost", "jeder","jeder")
or error(__LINE__,__FILE__,"Keine Verbindung zum
Datenserver",mysql_error());
mysql_select_db ("samp_db")
or error(__LINE__,__FILE__,"Kann Datenbank nicht öffnen",mysql_error());
}
function query_list(){
$lquery = "SELECT state,count(state)"
. " FROM president"
. " GROUP BY state"
. " ORDER BY state";
/* Macht mit "GROUP BY state" staatenabhängige Gruppen,
die dann mit count gezählt werden.
Ansonsten würden alle Staaten gezählt. Das Ergebnis wäre immer das
gleiche.
Die Reihenfolge ist groop dann order*/
$lresult = mysql_query($lquery)
or error(__LINE__,__FILE__,"Kann Abfrage nicht ausführen",mysql_error());
return $lresult;
}
function print_select($lresult){
print("\n");
while($lrow=mysql_fetch_row($lresult)){
printf("%s (%s)\n",
$lrow[0],$lrow[0],$lrow[1]);
}
print("\n");
}
?>
Auswahl Präsidenten und Staaten
Die Präsidenten der US Bundesstaaten
Wählen sie den Bundesstaat
result_president.php
Einführung in MySQL und PHP Seite 35 von 37 Andreas Renner – BG. Gallus
\n");
print("NachnameVornameStadtStaat
GeburtTod\n");
while($lrow=mysql_fetch_row($lresult)){
print("\n");
for($i=0;$i%s \n",htmlspecialchars($lrow[$i]));
}
print("\n");
}
print("\n");
}
?>
Ergebnis: Präsidenten der US Bundesstaaten
Präsidenten der US Bundesstaaten
Bundesstaat: " . $zeichenkette . "\n");
$link = samp_db_pconnect();
$result= query_president($zeichenkette);
print_table($result);
mysql_free_result($result);
?>
18.2.9 Chechboxes und PHP
Im nächsten Beispiel sehen wir, wie mit PHP Checkboxes ausgewertet werden
können. Der Inhalt einer Checkboxgruppe namens mycheck wird bei der
Formularauswertung automatisch in einem PHP Array $mycheck gespeichert. Bei
dieser einfachen Variabelenübergaben von einem Formular an ein PHP Script,
muss in der php.ini Datei register_globals=on sein.
Und so lesen wir in PHP die Inhalte des Arrays $mycheck in die Variable $checked
foreach ($mycheck as $checked)
Einführung in MySQL und PHP Seite 36 von 37 Andreas Renner – BG. Gallus
check_box.html
Check-Box
Check-Box
Buchstabe a
Buchstabe b
Buchstabe c
Buchstabe d
Buchstabe e
Übergabeparameter an das auswertende PHP Script:
http://localhost/scriptum/u12/check_box.php?mycheck%5B0%5D=a&mycheck%5B2%5D=c&mycheck
%5B4%5D=e
%5B=[
%5D=]
check_box.php
Ergebnis von Check-Box
Ergebnis von Check-Box
";
}
?>
Ich hoffe ich konnte ihnen einen Einblick in die Welt von MySql, SQL, PHPMyAdmin und PHP geben,
der sie inspiriert selbst PHP Anwendungen zu schreiben. Dabei wünsche ich ihnen viel Erfog.
Ich danke auch Dipl. Ing. Leopold Moosbrugger, Abteilungsleiter für Elektrotechnik an der HTL
Rankweil. Dieser Kurs basiert auf seiner Fortbildung „Datenbanken mit Webanbindung“.
Andreas Renner, AHS Lehrer
Einführung in MySQL und PHP Seite 37 von 37 Andreas Renner – BG. Gallus