MySQL_Kurs by keralaguest

VIEWS: 13 PAGES: 37

									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<Passwort> -u <Benutzername> <DB-Name>
     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 <Benutzername> -p <DB-Name>
     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 <DB-Name> 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 < 19600101;
            +----------------+-----------+----------+------------+
            | personalnummer | vorname              | nachname | geburt            |
            +----------------+-----------+----------+------------+
            |               1008 | Eike             | Taro        | 1947-09-10 |
            |               1430 | Christine | Schwarz | 1948-04-24 |
            |               1437 | Christa          | Renner      | 1932-12-27 |
            |               1431 | Birgit           | Gemse       | 1958-01-13 |
            |               1433 | Silvia           | Munter      | 1952-04-28 |
            +----------------+-----------+----------+------------+
            5 rows in set (0.00 sec)

    7.5 Sortieren einer Abfrage
        Das Abfrageergebnis von vorhin soll nach Geburtsdatum in absteigender Reihenfolge
        aufgelistet werden.
            mysql>      select personalnummer,vorname,nachname,geburt from personal where
            geschlecht = 'W' and geburt < 19600101 order by geburt desc;
        Anstelle von geburt desc könnte man auch –geburt eingeben.

Einführung in MySQL und PHP                              Seite 7 von 37                Andreas Renner – BG. Gallus
        +----------------+-----------+----------+------------+
        | personalnummer | vorname   | nachname | geburt     |
        +----------------+-----------+----------+------------+
        |           1431 | Birgit    | Gemse    | 1958-01-13 |
        |           1433 | Silvia    | Munter   | 1952-04-28 |
        |           1430 | Christine | Schwarz | 1948-04-24 |
        |           1008 | Eike      | Taro     | 1947-09-10 |
        |           1437 | Christa   | Renner   | 1932-12-27 |
        +----------------+-----------+----------+------------+
        5 rows in set (0.01 sec)

 7.6 Abfrage von Daten aus mehreren Tabellen
     Bisher haben wir immer nur Daten aus einer Tabelle extrahiert. Jetzt holen wir Daten aus zwei
     Tabellen: In der Tabelle personal finden wir unsere Personen und in der Tabelle teilnehmer
     stehen Personen die eine Schulung besucht haben. Schauen wir uns die Felder der Tabelle
     teilnehmer genauer an.
         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          |                |
         +----------------+-----------------+------+-----+---------+----------------+
         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 <Directory>
             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/"
         <Directory "C:/phpdev/phpmyadmin/">
              Options Indexes FollowSymLinks MultiViews
              AllowOverride All
              Order allow,deny
              Allow from localhost 127.0.0.1
              DirectoryIndex index.php
         </Directory>

     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 <pma_db> 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:      <?php \\ Hier Beginnt der PHP Code
Mehrzeiliger Kommentar:     /* Hier kann mehrzeiliger Kommentar stehen */

Sie können den Code in eine Textdatei kopieren. Dieser Datei geben sie die Endung php und
kopieren sie ins Apache – Dokumentenverzeichnis. Über den Apache rufen sie dann die Datei auf:
(http://localhost/uebung1.php).

Vorausetzung für diese Übungen sind
    die Datenbank samp_db mit den
    Tabellen mitglieder und presidents. Die notwendigen Daten finden sie im Ordner
      MySQL_Kurs\samp_db .
    Ein Editor. Ich empfehle Phase 5.
    Die Onlinedokumentation: SelfPHP ( http://www.selfphp.info/ )

18.2.1 Übung 1: Öffnen und einfache Abfrage einer Datenbank mit PHP

Die Funktion mysql_pconnect
int mysql_pconnect([string hostname[:port][:/path/to/socket] [, string Benutzername [, string Kennwort]]])

      Mit mysql_pconnect() öffnet man eine persistente Verbindung zu einer MySQL-Datenbank. Im
      Erfolgsfall gibt diese Funktion eine Verbindungskennung, sonst false zurück. Falls keine
      Verbindung erstellt werden kann, können Sie eine eigene Fehlermeldung zum Browser senden
      und danach das Skript abbrechen lassen (siehe im Beispiel "or die").

      Falls Sie Zugriff auf eine MySQL-Datenbank im Internet haben, werden Sie die Zugangsdaten,
      die Sie von Ihrem Provider bekommen haben, in die dafür vorgesehenen Parameter eintragen
      müssen
      Fehlermeldungen, die eventuell auftreten und ausgegeben werden, können Sie mit einem "@"
      unterdrücken.
      Die Verbindung zur Datenbank wird nicht mit dem Skriptende geschlossen.
      Folgendes ist gegenüber mysql_connect() anders:
           Es wird versucht, vor dem Verbindungsaufbau eine persistente Verbindung zum
              gleichen Host mit dem gleichen Benutzer und Passwort zu erstellen. Gelingt dies, so
              wird die Verbindungskennung dieser Verbindung zurückgegeben.
           Die Verbindung wird nicht mit dem Beenden des Skripts geschlossen, sondern bleibt
              bestehen für einen zukünftigen Verbindungsaufbau.


      Die Funktion mysql_select_db
      int mysql_select_db(string Datenbankname [, int Verbindungs-Kennung])

      Mit mysql_select_db() wählt man eine Datenbank aus. Im Erfolgsfall gibt diese Funktion true,
      sonst false zurück. Als Parameter wird der Datenbankname (Datenbankname) gefordert. Sie
      können zusätzlich eine Verbindungskennung (Verbindungs-Kennung) mit angeben. Fehlt die
      Verbindungskennung, so wird die aktuelle Verbindungskennung genutzt.


      Die Funktion mysql_query()
      int mysql_query(string Anfrage [, int Verbindungs-Kennung])

      Mit mysql_query() sendet man eine SQL-Anfrage (Anfrage) an einen Datenbankserver. Wird der
      optionale Parameter der Verbindungskennung (Verbindungs-Kennung) nicht angegeben, so
      wird versucht, eine Verbindung ohne Angaben von Argumenten (siehe mysql_connect)
      aufzubauen. Die Funktion mysql_query() liefert im Erfolgsfall true, sonst false zurück. Beachten
      Sie bitte, dass diese Funktion keine Angaben über die Anzahl der Datensätze zurückgibt.



Einführung in MySQL und PHP                     Seite 24 von 37         Andreas Renner – BG. Gallus
     Die Funktion mysql_fetch_row()
     array mysql_fetch_row(int Ergebnis-Kennung)

     Mit mysql_fetch_row() kann man sich anhand einer Ergebnis-Kennung einen Datensatz in Form
     eines indizierten Arrays übergeben lassen. Im Erfolgsfall liefert diese Funktion den aktuellen
     Datensatz, sonst wird false zurückgegeben.


     Die Funktion mysql_query()
     int mysql_free_result(int Ergebnis-Kennung)

     Mit mysql_free_result() kann man anhand einer Ergebnis-Kennung den belegten Speicher
     wieder freigeben. Diese Funktion ist auf Servern mit sehr wenig Arbeitsspeicher sinnvoll, um die
     Resourcen wieder freizugeben. Nach Beendigung des Skripts wird der Speicher automatisch
     wieder freigegeben. Beachten Sie, dass nach dieser Funktion nicht mehr auf das Ergebnis Ihrer
     Anfrage zurückgegriffen werden kann, da dieses entfernt wurde

     <html>
     <head>
     <title>US Presidenten Quiz</title>
     </head>
     <body>
     <h2>Willkommen auf der US Presidenten
     Quiz Webseite.</h2>

     <?php
     /* Fehler werden im Browser nicht angezeigt */
     /* Mit pconnect wird eine persistete – dauerhafte - Verbindung zum
     Datenbankserver gemacht, die erst am Ende des Interpretierens
     geschlossen wird. Mit connect müssten immer neue Verbindungen gemacht
     werden. Die beiden „;“ wären für die Argumente Benutzer und
     Passwort.*/

     $link = @mysql_pconnect ("localhost", "jeder", "jeder")
        or exit ();

     mysql_select_db ("samp_db")
        or exit ();

     /* unter Anführungszeichen steht MySQl Code. Abschließendes “;” darf
     hier nicht stehen*/

     $result = mysql_query ("select count(*) from member")
        or exit ();

     /*Es werden mit fetch row Pointer auf alle Stalten gelegt und
     ausgelesen. Unsere Tabelle besteht aus 1. Spalte und einer Zeile * die
     mit der Count die Anzahl der Mitglieder liefert */

     if ($row = mysql_fetch_row ($result))

     /* echo und print sind gleich. Echo braucht keinen (), da es keine
     Funktion ist sondern ein Statement. Die Punkte sind Concatinate
     Anweisungen, die die Strings und Argumente zusammenhängen*/
        echo "<p>Die Liste hat im Augenblick " . $row[0] . "
     Mitglieder.\n";

     mysql_free_result ($result);
     ?>
     </body>
     </html>


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.


     <html>

Einführung in MySQL und PHP                   Seite 26 von 37         Andreas Renner – BG. Gallus
     <head>
     <title>US Presidenten Quiz Mitglieder Liste</title>
     </head>
     <body>
     <p><h1>US Presidenten Quiz Mitglieder Liste</h1>

     <?php

     $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&auml;hlen!");

     /*Die Punkte in der folgenden SQL Anweisung sind „concatenate“
     Zeichen. Sie werden verwendet, um mehrere Teile eines Strings
     zusammenzufügen. In der Regel handelt es sich dabei um Reintext und
     Variablen. Hier dient die Trennung des Gesamtstrings nur der
     Übersichtlichkeit. */

     $query =   "SELECT "
            .   " last_name, first_name, suffix, email,"
            .   " street, city, state, zip, phone"
            .   " FROM member"
            .   " ORDER BY last_name";

     $result = mysql_query ($query)
        or die ("Kann die Abfrage nicht ausf&uuml;hren!");

     print ("<table border=\"1\">\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 ("<tr>\n");
        for ($i=0; $i<mysql_num_fields ($result); $i++)
        {
     /*printf ist Print formatiert: Printf(Formatierung, Inhalt1,Inhalt2,
     ...) %s ist die Position des ersten Inhaltsarguments .
     htmlspecialchars ist eine Funktion, die aus Spezialzeichen (äöü ..)
     &auml; ... erzeugen. Der „;“ nach &nbsp macht in leere Felder eine „;“
     damit ein Tabellenrahmen erzeugt wird.*/
           printf ("<td>%s&nbsp;</td>\n", htmlspecialchars ($row[$i]));
        }
        print ("</tr>\n");
     }
     print ("</table>\n");

     mysql_free_result ($result);

     ?>
     </body>
     </html>




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
     <?php
     function samp_db_pconnect (){
     /*Gültigkeitsbereich von Variablen: $llink wird lokal in der Funktion
     definiert und hat nur dort Gültigkeit. Mit dem Retun wird die $llink
     wieder ans Programm zurückgegeben.*/
          $llink = @mysql_pconnect ("localhost", "jeder", "jeder")
              or die ("Kann den Datenbankserver nicht erreichen!");
          mysql_select_db ("samp_db")
              or die ("Kann die Datenbank nicht ausw&auml;hlen!");
          return $llink;
     }

     function query_member (){
        $lquery = "SELECT "
               . " last_name, first_name, suffix, email,"
               . " street, city, state, zip, phone"
               . " FROM member"
               . " ORDER BY last_name";
        $lresult = mysql_query ($lquery)
           or die ("Kann die Abfrage nicht ausf&uuml;hren!");
        return $lresult;
     }

     function print_table ($lresult){
        print ("<table border=\"1\">\n");
        while ($lrow = mysql_fetch_row ($lresult)){
            print ("<tr>\n");
            for ($i=0; $i<mysql_num_fields ($lresult); $i++)
            {
               printf ("<td>%s&nbsp;</td>\n", htmlspecialchars ($lrow[$i]));
            }
            print ("</tr>\n");
        }
        print ("</table>\n");
     }
     ?>
     <html>
     <head>
     <title>US Presidenten Quiz Mitglieder Liste</title>
     </head>
     <body>
     <p><h1>US Presidenten Quiz Mitglieder Liste</h1>
     <?php
     $link = samp_db_pconnect ();
     $result = query_member ();
     print_table ($result);
     mysql_free_result ($result);
     ?>
     </body>
     </html>



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:
               <input type = „text“ name=“nachname“ size=“20“>
   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
     <html>
     <head>
     <title>US Presidenten Quiz Abrage der
     Tabelle member</title>
     </head>
     <body>
     <h1>US Presidenten Quiz: Suche nach Mitgliedern</h1>
     <form action="result_get_table.php" method="get">
     Nachname:&nbsp;
     <input type = "text" name = "zeichenkette" size "20" maxlength="30"
     ></input>
     <input type = "submit" name = "Abschicken" value = "Abfrage"></input>
     <input type = "reset" value = "zurücksetzen"></input></input>
     </form>
     </body>
     </html>

     result_get_table.php
     <html>
     <head>
     <title>Auswertung: US
     Presidenten Quiz
     Abrage der Tabelle
     member</title>
     </head>
     <body text="#000000"
     bgcolor="#FFFFFF"
     link="#FF0000" alink="#FF0000" vlink="#FF0000">
     <?php
     function samp_db_pconnect() {
             $llink=mysql_pconnect("localhost","jeder","jeder")
                      or die("Kann den Datenbankserver nicht erreichen");
             mysql_select_db("samp_db")
                      or die("Kann die Datenbank nicht ausw&auml;hlen");
             return $llink;
     }

Einführung in MySQL und PHP                  Seite 29 von 37         Andreas Renner – BG. Gallus
     function query_member($lname){
              $lquery = "Select"
                     . " last_name, first_name, suffix, email,"
                     . " street, city, state, zip, phone"
                     . " from member"
                     . " where last_name like '" . $lname. "%'" // Wildcard: %
                     . " order by last_name";
              $lresult = mysql_query($lquery)
                     or die("Kann die Abfrage nicht ausf&uumlhren");
              return $lresult;
     }
     function print_table($lresult){
              print("<table border=\"1\">\n");
              while($lrow=mysql_fetch_row($lresult)){
                     print("<tr>");
                     for($i=0;$i<mysql_numfields($lresult);$i++){
                        printf ("<td>%s&nbsp;</td>\n", htmlspecialchars
     ($lrow[$i]));
                     }
                     print("</tr>\n");
              }
              print("</table>\n");
     }
     ?>

     <html>
     <head>
     <title>US Presidenten Quiz Abfrageergebnisse</title>
     </head>
     <body>
     <h2>Presidenten Quiz Webseite Abfrageergebnisse.</h2>

     <?php
     print("Formularwert: " . $zeichenkette);
     $link = samp_db_pconnect();
     $result = query_member($zeichenkette);
     print_table($result);
     mysql_free_result ($result);
     ?>
     </body>
     </html>




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- (<?PHP) und End-Tags (?>)
                eingebunden werden.

                Aufgabe:
                     Kopieren sie alle PHP Funktionen von result_get_table.php aus Übung 5 in eine Datei
                      namens samp_db.inc.
                 <?php
                 function samp_db_pconnect() {
                          $llink=mysql_pconnect("localhost","jeder","jeder")
                                     or die("Kann den Datenbankserver nicht erreichen");
                          mysql_select_db("samp_db")
                                     or die("Kann die Datenbank nicht ausw&auml;hlen");
                          return $llink;
                 }
                 function query_member($lname){
                           $lquery = "Select"
                                     . " last_name, first_name, suffix, email,"
                                     . " street, city, state, zip, phone"
                                     . " from member"
                                     . " where last_name like '" . $lname. "%'"
                                     . " order by last_name";
                           $lresult = mysql_query($lquery)
                                     or die("Kann die Abfrage nicht ausf&uuml;hren");
                           return $lresult;
                 }
                 function print_table($lresult){
                           print("<table border=\"1\">\n");
                           while($lrow=mysql_fetch_row($lresult)){
                                     print("<tr>");
                                     for($i=0;$i<mysql_numfields($lresult);$i++){
                                         printf ("<td>%s&nbsp;</td>\n", htmlspecialchars
                 ($lrow[$i]));
                                     }
                                     print("</tr>\n");
                           }
                           print("</table>\n");
                 }
                 ?>
                     Löschen sie diesen Teil aus der Datei result_get_table.php und includieren sie ihn mit:
                 <?php
                 include("samp_db.inc");
                 ?>

          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
      <html>
      <head>
      <title>Menüauswahl</title>

      </head>
      <body>
      <h1>Menüauswahl mit Select Feldern</h1>
      <form action="result_menu.php" method = "post">
      <select name = "auswahl" size = "1">
       <option value="1">eins
       <option value="2">zwei
       <option value="3" selected>drei
       <option value="4">vier
       <option value="5">fünf
      </select>
      <input type="Submit" name="submit" value="OK">
      <input type="reset">

      </form>
      </body>
      </html>

      result_menu.php
      <html>
      <head>
      <title>Menüauswahl Ergebnis</title>
      </head>
      <body>
      <h1>Das Ergebnis der Menüauswahl</h1>
      <?php printf("Es wurde %s ausgewählt",$auswahl); ?>
      </body>
      </html>


Im nächsten Schritt füttern wir die Formularauswahl mit
Werten aus der Datenbank.

form_get_table_select.php

<?php
function samp_db_pconnect()
{
   $llink = @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!");

    return $llink;
}

function query_list()
{
   // Select Distinct wählt nur unterschiedliche Datensätze aus


Einführung in MySQL und PHP                    Seite 32 von 37        Andreas Renner – BG. Gallus
    $lquery = "select distinct last_name"
           . " from member"
           . " order by last_name";
    $lresult = mysql_query($lquery)
           or die ("Kann die Abfrage nicht ausführen!");
    return $lresult;
}

function print_select($lresult)
{
print("<select name= \"zeichenkette\" size = \"1\">");
while($lrow=mysql_fetch_row($lresult)){
  printf("<option value = \"%s\">%s</option>\n",$lrow[0],$lrow[0]);
}
print("</select>");
}
?>

<html>
<head>
<title>Select Menu aus DB füllen</title>
</head>
<body text="#000000" bgcolor="#FFFFFF" link="#FF0000" alink="#FF0000"
vlink="#FF0000">
<h1>Select Menu aus der Datenbank mit den Nachnamen der Mitglieder
füllen</h1>

<?php
$link=samp_db_pconnect();
$result=query_list();
?>
<form action="result_get_table.php" method = "post">
<?php print_select($result); ?>
<input type="Submit" name="submit" value="OK">
<input type="reset">
</form>
<?php mysql_free_result($result); ?>
</body>
</html>

result_get_table.php


<?php
function samp_db_pconnect()
{
   $llink = @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!");

    return $llink;
}

function query_list()
{
   // Select Distinct wählt nur unterschiedliche Datensätze aus
   $lquery = "select distinct last_name"
          . " from member"
          . " order by first_name";
   $lresult = mysql_query($lquery)
          or die ("Kann die Abfrage nicht ausführen!");

Einführung in MySQL und PHP         Seite 33 von 37      Andreas Renner – BG. Gallus
    return $lresult;
}

function print_select($lresult)
{
print("<select name= \"zeichenkette\" size = \"1\">");
while($lrow=mysql_fetch_row($lresult)){
  printf("<option value = \"%s\">%s</option>\n",$lrow[0],$lrow[0]);
}
print("</select>");
}
?>

<html>
<head>
<title>Select Menu aus DB füllen</title>
</head>
<body text="#000000" bgcolor="#FFFFFF" link="#FF0000" alink="#FF0000"
vlink="#FF0000">
<h1>Select Menu aus der Datenbank mit den Nachnamen der Mitglieder
füllen</h1>

<?php
$link=samp_db_pconnect();
$result=query_list();
?>
<form action="result_get_table.php" method = "post">
<?php print_select($result); ?>
<input type="Submit" name="submit" value="OK">
<input type="reset">
</form>
<?php mysql_free_result($result); ?>
</body>
</html>


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
<?php
function error($line,$file,$string,$error=""){
  $fehler = "<b>Fehler in Zeile ".$line." in ".$file."</b> ";
  $fehler .= "<br>" . $string . "<br>"; if($error)

Einführung in MySQL und PHP                  Seite 34 von 37   Andreas Renner – BG. Gallus
    $fehler .= "<b>MySQL-Error:</b> ". $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("<select size = \"1\" name = \"zeichenkette\">\n");
while($lrow=mysql_fetch_row($lresult)){
   printf("<option value = \"%s\">%s&nbsp;(%s)</option>\n",
          $lrow[0],$lrow[0],$lrow[1]);
}
print("</select>\n");
}
?>

<html>
<head>
<title>Auswahl Präsidenten und Staaten</title>
</head>
<body>
<h1>Die Präsidenten der US Bundesstaaten</h1>
<h3>Wählen sie den Bundesstaat</h3>
<form action="result_president.php" method = "post">
<?php
$link = samp_db_pconnect();
$result = query_list();
print_select($result);
?>
<input type="Submit" name="submit" value="Auswählen">
<input type="reset">
</form>
</body>
</html>


result_president.php




Einführung in MySQL und PHP          Seite 35 von 37    Andreas Renner – BG. Gallus
<?php
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_president($lstate){
$lquery = "SELECT last_name, first_name, city, state, birth, death"
        . " FROM president"
        . " WHERE state = \"" . $lstate . "\""
        . " ORDER BY last_name";
$lresult = mysql_query($lquery);
return $lresult;
}

function print_table($lresult){
print("<table border = \"1\">\n");
print("<tr><th>Nachname</th><th>Vorname</th><th>Stadt</th><th>Staat</th>
       <th>Geburt</th><th>Tod</th></tr>\n");
while($lrow=mysql_fetch_row($lresult)){
   print("<tr>\n");

   for($i=0;$i<mysql_num_fields($lresult);$i++){
       printf("<td>%s&nbsp;</td>\n",htmlspecialchars($lrow[$i]));
       }
   print("</tr>\n");
   }
print("</table>\n");
}
?>
<html>
<head>
<title>Ergebnis: Präsidenten der US Bundesstaaten</title>
</head>
<body>
<h1>Präsidenten der US Bundesstaaten</h1>
<?php
print("<h3>Bundesstaat: " . $zeichenkette . "</h3>\n");
$link = samp_db_pconnect();
$result= query_president($zeichenkette);
print_table($result);
mysql_free_result($result);
?>
</body>
</html>

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
<html>
<head>
<title>Check-Box</title>
</head>
<body>
   <h1>Check-Box</h1>
   <form action="check_box.php" method="GET">
       Buchstabe a<input type="Checkbox" name="mycheck[0]"                   value="a"><br>
       Buchstabe b<input type="Checkbox" name="mycheck[1]"                   value="b"><br>
       Buchstabe c<input type="Checkbox" name="mycheck[2]"                   value="c"><br>
       Buchstabe d<input type="Checkbox" name="mycheck[3]"                   value="d"><br>
       Buchstabe e<input type="Checkbox" name="mycheck[4]"                   value="e"><br>
       <input type="Submit" name="" value="Abschicken">
   </form>
</body>
</html>

Ü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


<html>
<head>
<title>Ergebnis von Check-Box</title>
</head>
<body>
   <h1>Ergebnis von Check-Box</h1>
   <?php

/* wenn mindestens ein Element der Checkbox angehakt war. */
      if (!empty ($mycheck))
/* Übertragen werden nur Checkboxen, die angehakt waren. Also steht hier
überall was drinnen.*/
         foreach ($mycheck as $checked)
         {
            echo $checked . "<br>";
         }
   ?>
</body>
</html>



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

								
To top