Ces pages sont destinées à des personnes ayant déjà programmé. Il ne s'agit absolument pas d'un cours d'algorithmique. En particulier: les notions de bases de l'algorithmique (séquence, alternative, itération) sont supposées connues et comprises. On ne traitera ici que de leur traduction en PHP.

Les notions abordées seront:

Ces pages ont pour origine un cours destiné aux étudiants de 2^ème année de l'IUP IIES de l'université de Lille III-Charles de Gaulle, à Villeneuve d'Ascq, pour les années universitaires 2002-2003 et 2003-2004.

Elles ont ensuite été peu à peu remaniées et augmentées à l'occasion d'un cours destiné aux étudiants de 3^ème année de la licence MIASHS.

Ces pages ne sont pas destinées à être un cours autonome : elles ne sont qu'un support de cours, et beaucoup de choses, qui sont transmises à l'oral pendant les cours, ne sont pas écrites.

L'environnement technique du cours est constitué de machines sous linux. L'installation de ces logiciels ne sera pas abordée et ne fait pas partie du contenu du cours.

Ce polycopié a été rédigé au format DocBook :

Ce document est disponible sous plusieurs formats sur le web:

Les petites images animées qui illustrent les liens de la version web de ce document proviennent de QBullets

On appelle langage informatique un langage destiné à décrire l'ensemble des actions consécutives qu'un ordinateur doit exécuter. Les langages naturels (l'anglais, le français) représentent l'ensemble des façons qu'ont un groupe d'individu de communiquer. Les langages servant aux ordinateurs à communiquer n'ont rien à voir avec des langages informatiques, on parle dans ce cas de protocoles, ce sont deux notions totalement différentes. Un langage informatique est une façon pratique pour nous (humains) de donner des instructions à un ordinateur.

Un langage informatique est rigoureux : à CHAQUE instruction correspond UNE action du processeur.

Le langage utilisé par le processeur, c'est-à-dire les données telles qu'elles lui arrivent, est appelé langage machine. Il s'agit d'une suite de 0 et de 1 (du binaire) mais pour plus de « clarté » il peut être décrit en hexadécimal. Toutefois le langage machine n'est pas compréhensible facilement par l'humain moyen.

Ainsi il est plus pratique de trouver un langage intermédiaire, compréhensible par l'homme, qui sera ensuite transformé en langage machine pour être exploitable par le processeur.

L'assembleur est le premier langage informatique qui ait été utilisé. Celui-ci est encore très proche du langage machine mais il permet déjà d'être plus compréhensible. Toutefois un tel langage est tellement proche du langage machine qu'il dépend étroitement du type de processeur utilisé (chaque type de processeur peut avoir son propre langage machine). Ainsi un programme développé pour une machine ne pourra pas être porté sur un autre type de machine (on désigne par portable un programme qui peut être utilisé sur un grand nombre de machines). Pour pouvoir l'utiliser sur une autre machine il faudra alors parfois réécrire entièrement le programme !

Un langage informatique a donc plusieurs avantages :

Les langages informatiques peuvent grossièrement se classer en deux catégories : les langages interprétés et les langages compilés.

Un langage informatique est par définition différent du langage machine. Il faut donc le traduire pour le rendre intelligible du point de vue du processeur. Un programme écrit dans un langage interprété a besoin d'un programme auxiliaire (l'interpréteur) pour traduire au fur et à mesure les instructions du programme.

Un programme écrit dans un langage dit « compilé » va être traduit une fois pour toutes par un programme annexe (le compilateur) afin de générer un nouveau fichier qui sera autonome, c'est-à-dire qui n'aura plus besoin d'un programme autre que lui pour s'exécuter (on dit d'ailleurs que ce fichier est exécutable).

Un programme écrit dans un langage compilé a comme avantage de ne plus avoir besoin, une fois compilé, de programme annexe pour s'exécuter. De plus, la traduction étant faite une fois pour toute, il est plus rapide à l'exécution. Toutefois il est moins souple que programme écrit avec un langage interprété car à chaque modification du fichier source (fichier intelligible par l'homme : celui qui va être compilé) il faudra recompiler le programme pour que les modifications prennent effet.

D'autre part, un programme compilé a pour avantage de garantir la sécurité du code source. En effet, un langage interprété, étant directement intelligible (lisible), permet à n'importe qui de connaître les secrets de fabrication d'un programme et donc de copier le code voire de le modifier. Il y a donc risque de non-respect des droits d'auteur. D'autre part, certaines applications sécurisées nécessitent la confidentialité du code pour éviter le piratage (transaction bancaire, paiement en ligne, communications sécurisées, etc.).

Certains langages appartiennent en quelque sorte aux deux catégories (LISP, Java, Python, etc.) car le programme écrit avec ces langages peut dans certaines conditions subir une phase de compilation intermédiaire vers un fichier écrit dans un langage qui n'est pas intelligible (donc différent du fichier source) et non exécutable (nécessité d'un interpréteur). Les applets Java, petits programmes insérés parfois dans les pages Web, sont des fichiers qui sont compilés mais que l'on ne peut exécuter qu'à partir d'un navigateur internet (ce sont des fichiers dont l'extension est « class »).

Une réponse générale s'impose : pour obtenir des pages web dynamiques.

Attention, parler de « pages web dynamiques » ne signifie pas qu'on parle nécessairement de pages où tout bouge dans tous les sens. Il s'agit simplement de pages qui n'ont pas d'existence statique, et qui sont construites à la volée, au momment où elles sont demandées au serveur.

Leur utilité se fait sentir quand on doit écrire des pages qui doivent s'adapter (besoin de l'heure, accès à des bases de données, réponse personnalisée, traitement de formulaire, etc.), mais aussi pour faciliter la gestion d'un site (de grande taille par exemple), séparation du contenu (la structure) et du traitement (la présentation).

Beaucoup. Pratiquement tous les langages de programmation peuvent être utilisés, et il existe des langages spécifiques à la programmation web.

On les classes en deux catégories :

Lequel choisir ? Bof ! Ça dépend de ce qu'on veut faire. La seule chose certaine c'est que les fonctions importantes (vitales pour l'affichage ou mettant en jeu la sécurité du site) ne doivent pas être confiées à un script qui s'exécute côté client.

À quoi ça ressemble ? Vous trouverez de quoi tester tout ça dans les pages de Fabien Torre.

PHP est un langage de scripting embarqué dans les pages HTML et traité par le serveur. PHP permet de construire dynamiquement des pages HTML contenant les résultats de calculs ou de requêtes SQL adressées à un système de gestion de bases de données (SGBD).

Javascript est lui aussi en effet intégré dans les pages HTML mais Javascript est intéprété par le client Web alors que PHP est directement interprété par le serveur Web (s'il est inclus comme étant un module du serveur web). Le client web recoit donc directement du HTML et ne voit jamais apparaître le code PHP.

Il n'y a pas à choisir entre PHP ou Javascript. En réalité leur utilisation est différente : Javascript est très bien adapté à l'aspect présentation et manipulation du client Web. PHP est lui adapté à la création de page HTML dynamique et rapide. PHP permet de faire des pages HTML dynamiques, dans le sens que deux appels consécutifs à une URL peuvent donner deux pages HTML différentes. Mais chacune de ces pages est statique. On peut dire qu'au niveau du serveur la page est dynamique alors qu'elle apparait comme étant statique au niveau du client Web. Javascript permet lui de générer une page dynamique pour le client Web, c'est une des principales différences entre ces deux outils de développement.

L'interpréteur intégré fonctionne de la manière suivante :

Il importe de signaler que les programmes PHP ne sont pas transmis au client mais exécutés sur le serveur. Le poste client ne fera pas de différence entre les pages statiques et celles générées dynamiquement. Il n'y a donc pas lieu de configurer spécialement les navigateurs pour supporter PHP.

Pour que le serveur HTTP reconnaisse du code PHP il faut que :

Bien que les possibilités du langage PHP soient étendues, il suffit d'une connaissance élémentaire du langage pour réaliser les applications Web courantes.

Ce langage dispose d'une bibliothèque de fonctions très étendue. Elle fournit en particulier un interface avec les principaux systèmes de gestion de base de données et avec le système de gestion de fichier du serveur. On se reportera à la documentation du langage pour la description de ces fonctions.

      <html><body>
      <?php
        echo "Hello world!";
      ?>

      </body></html>

Pour voir le résultat produit : helloworld.php

En allant voir le code source de la page produite (sur votre navigateur) vous ne verrez que cela :

      <html><body>
      Hello world!
      </body></html>

C'est normal : souvenez-vous que le serveur exécute le programme et n'envoie au client que le résultat, pas le programme lui-même.

      <html><body>
      <?php
        phpinfo();
      ?>
      </body></html>

Pour voir le résultat produit : phpinfo.php

Une fonction sans paramètres se définit par :

      function nom_de_la_fonction () {
        corps_de_la_fonction
      }

Une fonction avec paramètres se définit par :

      function nom_de_la_fonction (paramètres) {
        corps_de_la_fonction
      }

Les paramètres sont toujours passés par valeur.

Le résultat de la fonction est la valeur qui se trouve derrière la première instruction return rencontrée. Par exemple « return 5; ».

Il n'y a pas de procédures : si vous voulez qu'une de vos fonctions se comporte comme une procédure, il suffit de ne lui faire renvoyer aucune valeur, par exemple avec « return; ».

Dans les exercices qui suivent vous ferez en sorte que les résultats soient présentés proprement (je vous laisse libre choix sur le sens exact de ce mot...).

Les formulaires de saisie permettent à l'utilisateur de fournir des informations et ainsi d'obtenir une réponse personnalisée. Les informations contenues dans les champs remplis par l'utilisateur sont transmises par le programme client au serveur qui les transmet à son tour à un programme de traitement, soit un CGI (Common Gateway Interface), soit un script de type PHP.

La structure d'un formulaire de saisie est simple, elle se compose d'un élément FORM contenant essentiellement une suite de contrôles (éléments input, textarea, select, button, etc.) mais aussi des éléments de structuration de document afin d'aligner correctement les champs d'entrée.

Globalement un formulaire se présente sous cette forme :

        <form method="(1)" action="(2)">
          du texte, des boutons, des zones de saisie ...
          <input type="submit" value="(3)" />
        </form>
      

où :

Dans l'affichage de la page, rien ne distingue le formulaire du reste du texte. Il est donc conseillé de le séparer du reste par la balise « <hr /> » avant et après, ou le mettre dans un tableau aux bordures visibles.

Les principaux contrôles sont :

Vous pourrez trouver deux exemples (presque identiques, sauf pour la méthode d'envoi : GET pour l'un, POST pour l'autre) aux adresses suivantes :

Vous pouvez tester vos propres formulaires en suivant les instructions de la page :

Votre formulaire doit contenir un attribut caché identifiant et le champ action doit contenir la valeur :

Tout programme PHP peut recevoir des variables.

Si on connaît par avance le nom des variables qui seront passées au programme, il suffit de les appeler par leur nom (avec la syntaxe PHP, c'est-à-dire précédé d'un $).

Par exemple l'appel de l'URL suivante

        http://grappa.univ-lille3.fr/~gonzalez/prog/form01.php3?x=5&y=7

autorise l'emploi des variables « $x » (qui vaut 5) et « $y » (qui vaut 7) dans le programme « form01.php3 ».

La question est donc : quelles variables (avec quelles valeurs) sont transmises par un formulaire ? Les noms des variables sont ceux des champs du formulaire.

Pour les zones de saisies, le texte tapé est transmis tel quel. Pour les cases à cocher, la valeur est « on » si la case a été cochée, une chaîne vide sinon. Pour les boutons radios c'est la valeur affectée à « value » pour le bouton sélectionné. Pour les listes déroulantes, c'est la valeur affectée à « option » pour le choix sélectionné.

Trois choses à savoir :

C'est pareil, sauf que :

Le caractère backslash (« \ ») permet d'introduire dans les chaînes des caractères qui ne pourraient pas y être sinon (par exemple des guillemets dans une chaîne entourée de guillemets, des retours à la ligne, etc...). Comme il est de ce fait lui même un caractère spécial, il faut une façon particulière de le noter pour qu'il soit inclus dans une chaîne. Ce sera « \\ ».

Voici un tableau récapitulant les principales utilisations du backslash :

Il ne s'agit là que des fonctions principales, et elles ne seront pas expliquées, ce qui signifie qu'il vous faudra aller voir dans la documentation de PHP par vos propres moyens.

PHP est extrémement tolérant sur les conversions de types et essaiera toujours de faire le mieux et le plus naturellement possible.

N'en profitez quand même pas trop et prévoyez (et comprenez) toujours son comportement, cela vous évitera sans doute des déconvenues...

Un exemple de ce qu'on peut faire (mais évitez d'en abuser...) :

                <?php
                    $truc = "5";
                    echo $truc."  ".gettype($truc)."<br />\n";
                    $truc = $truc."2";
                    echo $truc."  ".gettype($truc)."<br />\n";
                    $truc = $truc*5;
                    echo $truc."  ".gettype($truc)."<br />\n";
                    $truc = $truc."2";
                    echo $truc."  ".gettype($truc)."<br />\n";
                    $truc = $truc/100;
                    echo $truc."  ".gettype($truc)."<br />\n";
                ?>

Ce programme affichera :

                5 string
                52 string
                260 integer
                2602 string
                260.2 double

Écrire un formulaire qui devra vérifier l'identité de l'utilisateur en demandant un nom, un prénom et un mot de passe (ce dernier ne devra pas apparaître à l'écran pendant la frappe).

Tant que l'utilisateur n'est pas reconnu, seul s'affiche le formulaire.

Si l'utilisateur est reconnu, seul s'affiche un message d'accueil.

La casse des valeurs ne devra être prise en compte (c'est-à-dire le fait que ce soit tapé en majuscules ou en minuscules ne devra pas changer le comportement des pages).

Les espaces tapés en début ou en fin de mot de passe, de nom ou de prénom devront être éliminés.

Vous trouverez un exemple sur la page identite.php

Pour simplifier, voici 3 définitions équivalentes :

D'une manière plus générale :

Il s'agit d'une généralisation des tableaux, mais au lieu d'utiliser des nombres pour les indices on peut utiliser n'importe quoi...

Ce programme (tableau-04.php) permet de choisir un prénom dans une liste déroulante et d'afficher les renseignements correspondants.

        <html><body>
        <form action="tableau-04.php">
          <select name="prenom">
            <option value="Thècle">Thècle</option>
            <option value="Édith">Édith</option>
            <option value="Kelly">Kelly</option>
            <option value="Mélusine">Mélusine</option>
            <option value="Elmer">Elmer</option>
          </select>
          <input type="submit" value="renseignements" />
        </form>
        <?php
        $nom["Thècle"]="Assicmonpote";
        $nom["Édith"]="Avuleur";
        $nom["Kelly"]="Diocy";
        $nom["Mélusine"]="Enfaillite";
        $nom["Elmer"]="Hitmieux";
        $adresse["Thècle"]="123 rue Alex KUZBIDON";
        $adresse["Édith"]="951 rue Ondine OUCESOIR";
        $adresse["Kelly"]="5 boulevard Rosa REMECITOYENS";
        $adresse["Mélusine"]="7 rue Jean TANLAMER";
        $adresse["Elmer"]="99 avenu Dino ZORE";
        $ville["Thècle"]="Rennes";
        $ville["Édith"]="Douarnenez";
        $ville["Kelly"]="Auchel";
        $ville["Mélusine"]="Chamonix";
        $ville["Elmer"]="Langres";

        if (isset($prenom)) {
          echo "Prénom : $prenom<br />\nNom : ".$nom[$prenom]
              ."<br />\nAdresse : ".$adresse[$prenom]
              ."<br />\nVille : ".$ville[$prenom];
        }
        ?>
        </body></html>

Quand on travaille avec un tableau classique (à indice numérique), il est facile d'en parcourir toutes les cases avec une boucle for.

Mais pour parcourir un tableau associatif, c'est un peu moins direct. La méthode classique ne marche pas : la fonction count ne donne pas un résultat exploitable facilement dans le cas d'un tableau associatif. Il est alors difficile d'imaginer, par exemple pour l'exemple précédent, une boucle qui construirait automatiquement la suite « Thècle, Édith, Kelly, Mélusine, Elmer ».

Ces valeurs, il faut aller les chercher dans le tableau lui-même.

Ne nous énervons pas, PHP fournit tout ce qu'il faut. La structure foreach permet de parcourir un tableau associatif, comme dans le programme suivant (tableau-05bis.php).

Le programme tableau-05bis.php parcourt le tableau $nom, et en affiche le contenu, chaque ligne d'affichage contenant le couple clef-valeur (la clef correspondant à ce qu'on a l'habitude d'appeler indice quand il s'agit d'un nombre) :

        <html><body><table border="border">
        <?php
            $nom["Thècle"]="Assicmonpote";
            $nom["Édith"]="Avuleur";
            $nom["Kelly"]="Diocy";
            $nom["Mélusine"]="Enfaillite";
            $nom["Elmer"]="Hitmieux";
            foreach ($nom as $clef => $valeur) {
                echo "<tr><td>$clef</td><td>$valeur</td></tr>\n";
            }
        ?>
        </table></body></html>

.

L'extension PHP Data Objects (PDO) définit une excellente interface pour accéder à une base de données depuis PHP. Chaque pilote de base de données implémenté dans l'interface PDO peut utiliser des fonctionnalités spécifiques de chacune des bases de données en utilisant des extensions de fonctions. Notez que vous ne pouvez exécuter aucune fonction de base de données en utilisant l'extension PDO par elle-même ; vous devez utiliser un driver PDO spécifique à la base de données pour accéder au serveur de base de données.

PDO fournit une interface d'abstraction à l'accès de données, ce qui signifie que vous utilisez les mêmes fonctions pour exécuter des requêtes ou récupérer les données quelque soit la base de données utilisée. PDO ne fournit pas une abstraction de base de données : il ne réécrit pas le SQL, n'émule pas des fonctionnalités manquantes. Vous devriez utiliser une interface d'abstraction complète si vous avez besoin de cela.

PDO est fournit avec PHP 5.1 et est disponible en tant qu'extension PECL pour PHP 5.0 ; PDO requiert les nouvelles fonctionnalités OO fournies par PHP 5 et donc, ne fonctionne pas avec les versions antérieures de PHP.

L'hétérogénéité des moyens d'accès aux bases de données a été un des problèmes les plus gênants en PHP. Le problème vient du fait que, par exemple, les fonctions permettant l'accès à une base PostgreSQL sont différentes de celles pour MySQL, et elles sont toutes différentes de celles pour SQLite, etc.

Cela a pour effet de rendre plus difficile la migration d'un système vers un autre : vous avez écrit (par exemple en cours) un site utilisant une base PostgreSQL et vous voulez le transférer chez un hébergeur qui n'offre que MySQL (comme c'était par exemple le cas pour Free il y a encore peu de temps) : votre seule solution est de reprendre (et corriger) dans toutes vos pages tous les appels à des fonctions concernant PostgreSQL. Il peut y en avoir beaucoup...

Une couche d'abstraction^[1] permet d'éviter ce problème : tous vos accès à votre base de données passent par elle (avec la même syntaxe, quelle que soit la base de données) et c'est elle qui se débrouille pour s'adapter à la base de données utilisée. Pour changer de base de données (passer de PostgreSQL à MySQL par exemple) vous n'avez en général qu'à modifier une ligne, celle qui donne les paramètres de la base de données utilisée.

Les connexions sont établies en créant des instances de la classe de base de PDO. Peut importe quel driver vous voulez utiliser ; vous utilisez toujours le nom de la classe PDO. Le constructeur accepte des paramètres pour spécifier la source de la base de données (connue en tant que DSN) et optionnellement, le nom d'utilisateur et le mot de passe (s'il y en a un).

Il suffit pour cela d'exécuter la commande

Le nom de la variable $dbh est sans importance. Ce n'est qu'une variable, vous pouvez lui donner le nom qui vous plaît. Il faut seulement garder à l'esprit qu'il faut conserver cette variable (quelque soit son nom), c'est elle qui permettra d'accéder à la base de données avec les fonctions des sections suivants.

Le type_de_base quant à lui est une valeur parmi :

On se reportera à la page « Fonctions PDO » pour la gestion des erreurs de connexion.

Lorsque la connexion à la base de données a réussi, une instance de la classe PDO est retournée à votre script. La connexion est active tant que l'objet PDO l'est. Pour clore la connexion, vous devez détruire l'objet en vous assurant que toutes ses références sont effacées. Vous pouvez faire cela en assignant NULL à la variable gérant l'objet. Si vous ne le faites pas explicitement, PHP fermera automatiquement la connexion lorsque le script arrivera à la fin.

En ayant auparavant obtenu un identifiant de connexion $dbh (instance de la classe de base de PDO) comme précédemment, la syntaxe est simple :

La valeur renvoyée (rangée ici dans la variable $res) N'EST PAS le résultat de l'exécution de la requête, mais un identifiant (propre au système, sa valeur réelle ne nous intéresse pas^[2]) qui nous permettra d'accéder aux résultats grâce aux fonctions décrites ci-dessous.

On peut facilement obtenir le nombre de lignes et de colonnes du résultat d'une requête de type SELECT :

                $result = $dbh->query('SELECT id FROM table') ;
                echo $result->rowCount() ; // nombre de lignes
                echo $result->columnCount() ; // nombre de champs

Plus d'informations sur PHP net pour rowCount() et columnCount().

$result étant un résultat valide renvoyé par $dbh->query(), $result->fetchAll() renvoie un tableau à 2 dimensions qui contient les résultats : le premier indice concerne les lignes, le deuxième concerne les colonnes.

Plus d'informations sur PHP net pour fetchAll().

                    $result = $dbh->query("SELECT * FROM villes");
                    $data = $result->fetchAll();
                    foreach ( $data as $row ) {
                        echo $row["codepostal"]." - ".$row["ville"]."<br />\n";
                    }

                    $result = $dbh->query("SELECT * FROM villes");
                    $data = $result->fetchAll();
                    foreach ( $data as $row ) {
                        for ($i=0 ; $i<$result->columnCount() ; $i++) {
                            echo $row[$i]." ** ";
                        }
                        echo "<br />\n";
                    }

                    $result = $dbh->query("SELECT * FROM villes");
                    $data = $result->fetchAll();
                    for ($l=0;$l<$result->rowCount();$l++) {
                        for ($i=0;$i<$result->columnCount();$i++) {
                            echo $data[$l][$i]." ** ";
                        }
                        echo "<br />\n";
                    }

Quand une instruction PDO échoue, aucun message n'est affiché. On peut alors croire à tort que tout s'est bien passé. Il est donc important de savoir obtenir des informations sur d'éventuelles erreurs. Pour avoir des informations plus précises que ces quelques lignes, allez voir les pages dont elles sont extraites sur PHP.net.

Pour la suite nous continuerons à nous placer dans le cas où on a auparavant obtenu un identifiant de connexion $dbh (instance de la classe de base de PDO).

    $db->query($req);  // exécution de la reqête
    if ($db->errorCode()!=0) {   // il y a une erreur
        echo "<b>Erreur</b> sur la requête <tt>$req</tt><br />\n";
        $t=$db->errorInfo();   // récupération des informations sur l'erreur
        echo "<b>Code erreur SQLSTATE :</b> ".$t[0]."<br />\n";
        echo "<b>Code erreur spécifique au driver :</b> ".$t[1]."<br />\n";
        echo "<b>Message d'erreur :</b><blockquote><p>".$t[2]."</p></blockquote>\n";
        echo "<b>Le programme a été interrompu</b>";
        die();
    }

La programmation séparée c'est écrire un programme en plusieurs petits fichiers au lieu d'un seul gros.

Quelques avantages :

Les fonctions « require » et « include » permettent d'inclure un fichier dans un autre.

Il est dit par exemple :

Différentes façons d'utiliser ces fonctions :

Ces façons de faire n'ont pas seulement l'avantage de vous permettre de ne pas taper plusieurs fois la même chose pour vous éviter une fatigue inutile (surtout que le copier-coller marche bien).

Leur utilité est surtout de rendre les modifications faciles à répercuter : si vous décidez de changer la présentation globale de votre site, il n'y a qu'un seul fichier à modifier ; si vous décidez de modifier la partie de code commune (une façon de faire un calcul, la façon de se connecter, etc.), il n'y a également qu'un seul fichier à modifier.

La fonction header permet de spécifier une en-tête HTTP lors de l'envoi des fichiers HTML. Reportez-vous à HTTP 1.1 Specification pour plus d'informations sur les en-têtes HTTP.

Nous allons utiliser ici cette fonction pour demander la vérification d'une identité.

Pour cela il suffit de faire commencer votre programme PHP par la commande :

        header("WWW-Authenticate: Basic realm='private'");

qui a pour effet de faire demander (et retenir) un nom et un mot de passe par le navigateur.

Vous pouvez ainsi tester le programme élémentaire suivant (ident-exple01.php) :

        <?php
        if (!isset($PHP_AUTH_USER) || !isset($PHP_AUTH_PW)) {
          header("WWW-Authenticate: Basic realm='private'");
        } else {
          echo "<html><body>";
          echo "les données connues sont $PHP_AUTH_USER et $PHP_AUTH_PW\n";
          echo "</body></html>";
        }
        ?>

Vous pouvez remarquer que la demande n'est faite que lors de la première exécution de la page. La seule façon, avec le programme tel qu'il est écrit, de devoir répondre à nouveau à la question est de sortir de votre navigateur (fermer toutes les fenêtres du navigateur, oui !) et de le relancer.

C'est cette propriété que nous allons utiliser pour gérer l'identification des utilisateurs.

Il ne manque qu'une seule chose (ou presque !) au programme précédent pour être parfait : tester les valeurs des variables $PHP_AUTH_USER (qui contient le nom) et $PHP_AUTH_PW (qui contient le mot de passe) pour vérifier qu'on a affaire à la bonne personne.

Une version simple pourrait ressembler à ça (ident-exple02.php) :

        <?php
        if (($PHP_AUTH_USER=="marcel") && ($PHP_AUTH_PW=="bidule")) {
          echo "<html><body>";
          echo "Bravo, identification réussie.\n";
          echo "</body></html>";
        } else {
          header("WWW-Authenticate: Basic realm='private'");
        }
        ?>

Il est rare, quand l'accès à une page est contrôlée par un mot de passe, que tous les utilisateurs aient les mêmes droits.

Il faut donc pouvoir détecter l'identité de la personne concernée au moment de la saisie du mot de passe. Pour cela on donnera un mot de passe différent à chaque utilisateur. Cela nous permet d'avoir l'exemple suivant (ident-exple03.php) dans lequel les renseignements sont rangés dans un tableau de chaînes de caractères, une chaîne par personne, présentée sous la forme « vrai nom/nom d'utilisateur/mot de passe » :

        <?php
        // la liste des informations
        $liste=array("Jean Némar/nemar/jjjj",
                     "Sophie Fonfec/fonfec/ssss",
                     "Yves Adrouille-Toultan/adrouille/yyyy");
        // création des tableaux
        for ($i=0;$i<count($liste);$i++) {
          $l=explode("/",trim($liste[$i]));
          $nom[$i]=$l[0];  // identité réelle de l'utilisateur n°i
          $user[$i]=$l[1]; // identifiant de l'utilisateur n°i sur le système
          $pass[$i]=$l[2]; // mot de passe de l'utilisateur n°i
        }
        $nbusers=count($liste);
        // contrôle de l'identité
        $ok=-1; // on démarre sans connaître l'utilisateur
        for ($i=0;$i<$nbusers;$i++) {
          if (($PHP_AUTH_USER==$user[$i]) && ($PHP_AUTH_PW==$pass[$i])) {
            // on a reconnu un utilisateur -> on garde son numéro
            $ok=$i;
          }
        }
        // si l'identification a raté, $ok contient toujours -1
        // on demande le nom et le mot de passe
        if ($ok==-1) {
          header("WWW-Authenticate: Basic realm='private'");
          return; // On notera l'utilisation de l'instruction return
                  // pour sortir du programme.
        }
        // si on arrive ici, c'est que l'identification a réussi
        // et que $ok contient le numéro de l'utilisateur
        echo "<html><body>";
        echo "Bravo, identification réussie.<br />\n";
        echo "vous êtes <em>nom[$ok]</em>,\n";
        echo "votre identifiant est <em>$user[$ok]</em>,\n";
        echo "votre mot de passe est <em>$pass[$ok]</em>.<br />\n";
        // À vous d'ajouter ici tout ce qui concerne l'utilisateur
        // ...
        // ...
        echo "</body></html>";
        ?>

Il est tout à fait raisonnable d'imaginer qu'on va avoir besoin de changer les mots de passe, ainsi qu'ajouter des nouveaux utilisateurs ou en supprimer des anciens.

Il n'est par contre pas raisonnable du tout d'imaginer que celui qui va le faire aura envie d'aller manipuler à chaque fois le fichier du programme. (Ce n'est même d'ailleurs pas souhaitable...)

Il est donc préférable de garder ces informations dans un fichier séparé.

Qu'est-ce que cela change ? Pas grand chose : il suffit par exemple de remplacer les premières lignes :

      // la liste des informations
      $liste=array("Jean Némar/nemar/jjjj",
                   "Sophie Fonfec/fonfec/ssss",
                   "Yves Adrouille-Toultan/adrouille/yyyy");

par la lecture d'un fichier contenant les mêmes informations :

 
      // lire la liste des informations 
      $liste=file("mettre ici le chemin d'accès au fichier");

Le reste du programme ne change pas.

Le fichier à lire sera alors un simple fichier texte, qui contiendra dans le cas présent :

      Jean Némar/nemar/jjjj
      Sophie Fonfec/fonfec/ssss
      Yves Adrouille-Toultan/adrouille/yyyy

La solution précédente a un très gros inconvénient si vous placez le fichier de mots de passe n'importe où... N'oubliez pas que les pages web (HTML et PHP) sont faites pour être vues par tout le monde, depuis n'importe où. Pour permettre cela les droits d'accès de l'arborescence web sont positionnés à lisible par tous (« chmod a+r* ») et il ne faut surtout pas changer cela.

Ça ne posera aucun problème, tant que vous n'y entreposez pas de données confidentielles.

Mais les mots de passe, ça c'est confidentiel !

Alors, comment faire ?

Il suffit de ne pas mettre votre fichier de mot de passe dans l'arborescence web, mais de lui choisir un emplacement quelconque dont la seule obligation est d'être accessible pour l'utilisateur apache (c'est lui qui exécute les programmes PHP).

Son chemin d'accès dans l'instruction

        $liste=file("mettre ici le chemin d'accès au fichier");

devra être absolu, c'est-à-dire partir de la racine et commencer par un slash (/).

Afin de ne pas rendre la vie trop facile à un éventuel pirate, il peut aussi être intéressant de crypter les mots de passe qui sont dans le fichier.

Cela se fait avec la fonction crypt.

Il n'y a pas d'algorithme de décryptage.

Mais il ne faut pas croire que cela puisse être une protection suffisante. En effet si les mots de passe, même cryptés, sont accessibles, il suffit de recopier chez soi les versions cryptées, et de les décoder tranquillement par la force brute.

Vous pourrez trouver un exemple de ce que cela signifie en exécutant le programme suivant decrypt.php :.

Il décrypte tout mot de passe dont vous fournissez la version cryptée d'une manière totalement inintelligente, voire même plutôt bestiale : il essaie toutes les chaînes de caractères possibles (en commençant par 1 caractère, puis 2, etc.) en les énumérant systématiqument (par exemple pour 2 caractères : aa, ab, ac, ad, ae, ... , az, ba, bc, ...). Pour chaque chaîne il calcule sa version cryptée (avec la fonction crypt) et la compare à celle qu'on lui a fournie. Quand elles sont identiques, il sait qu'il vient de trouver le mot de passe.

Idiot, d'accord, mais ça marche.

Et tout cela avec un programme qui n'est pas vraiment optimisé, et dans un langage qui n'est pas le plus rapide...

Il faut donc vraiment cacher les mots de passe...

Le texte qui suit est une partie de la page consacrée aux sessions sur le site de http://fr.php.net :

La seule fonction nécessaire pour un usage simple des sessions est session_start(), mais je ne peux que vous encourager à aller voir les autres

Principe :

La fonction à utiliser est « pg_connect ».

Syntaxe résumée :

                $www = pg_connect ("host=xxx dbname=ddd user=yyy password=zzz") ;

Avec :

La fonction à utiliser est « pg_query ».

Syntaxe résumée :

                $rrr = pg_query ($www, $requete) ;

Avec :

Les fonctions à utiliser sont :

Ce programme

                <?php
                $c=pg_connect ("dbname=**** user=**** password=****");
                $r=pg_query ($c , "SELECT nom,prenom FROM emp ORDER BY nom");
                for ($i=0; $i<pg_numrows($r); $i++) {
                    $l=pg_fetch_array($r,$i);
                    echo $l["prenom"]." <em>".$l["nom"]."</em>.\n";
                }
                ?>

produit le résultat suivant :

Les requêtes de type INSERT, UPDATE, et DELETE seront exécutées de la même manière que les requêtes de type SELECT, avec la fonction « pg_query ».

Il sera cependant important de contrôler les résultats de cette exécution. C'est ce que nous allons étudier dans ce chapitre.

Vous pouvez avoir envie de gérer vous-même les erreurs vos requêtes (par exemple éviter l'affichage des « Warning » et autres « Query failed »).

Pour cela il suffit de préfixer les fonctions que vous utilisez avec « @ » (opérateur de contrôle d'erreur) : lorsque cet opérateur est ajouté en préfixe d'une expression PHP, les messages d'erreur qui peuvent être générés par cette expression seront ignorés.

Par exemple au lieu d'écrire

            $res = pg_query ($c,$req) ;

on écrira

            $res = @pg_query ($c,$req) ;

Il est impératif, quand vous supprimez les avertissements, de gérer vous-même les erreurs qui peuvent survenir.

Dans le cas d'accès à une base PostgreSQL il existe un certain nombre de fonctionnalités pour cela.

                if ( $r=@pg_query($c,$req) ) {
                    // traitement cas de succès
                    . . . 
                } else {
                    // traitement cas d'échec
                    . . . 
                }

pear (PHP Extension and Application Repository) est une archive de composants PHP réutilisables et un projet majeur de la communauté PHP.

C'est une archive stockant de la façon la plus exhaustive possible des programmes, des macros et de la documentation. Son but est de fournir aux développeurs de bibliothèques/modules PHP un moyen d'organiser leur code PHP ou C d'une manière définie et partagée par les autres développeurs, ainsi que d'offrir à la communauté PHP une seule source pour ces ressources. En bref, c'est une architecture et un système de distribution pour composants PHP réutilisables.

pear est utile pour tout développeur PHP.

Mais nous allons surtout l'utiliser pour son module DB (DataBase) qui est une couche d'abstraction pour les accès aux bases de données.

L'hétérogénéité des moyens d'accès aux bases de données a été un des problèmes les plus gênants en PHP^[3]. Le problème vient du fait que, par exemple, les fonctions permettant l'accès à une base PostgreSQL sont différentes de celles pour MySQL, et elles sont toutes différentes de celles pour SQLite, etc.

Cela a pour effet de rendre plus difficile la migration d'un système vers un autre : vous avez écrit (par exemple en cours) un site utilisant une base PostgreSQL et vous voulez le transférer chez un hébergeur qui n'offre que MySQL (Free, par exemple) : votre seule solution est de reprendre (et corriger) dans toutes vos pages tous les appels à des fonctions concernant PostgreSQL. Il peut y en avoir beaucoup...

Une couche d'abstraction^[4] permet d'éviter ce problème : tous vos accès à votre base de données passent par elle (avec la même syntaxe, quelle que soit la base de données) et c'est elle qui se débrouille pour s'adapter à la base de données utilisée. Pour changer de base de données (passer de PostgreSQL à MySQL par exemple) vous n'avez en général qu'à modifier une ligne, celle qui donne les paramètres de la base de données utilisée.

Vous trouverez sur le web de la documentation en français sur pear, et en particulier le module peardb.

Pour que les fonctions de peardb soient utilisables dans votre programme, il doit commencer par :

La première action, avant d'utiliser une base de données, est de s'y connecter.

Pour cela il faut définir un DSN (Data Source Name) qui donnera tous les renseignements sur la base de données à utiliser : nom, utilisateur, mot de passe, machine hébergeant le serveur, type de SGBD, etc. Sa syntaxe (légèrement simplifiée) est la suivante  :

Par exemple :

Il suffit ensuite d'exécuter la commande

Le nom de la variable $db est sans importance. Ce n'est qu'une variable, vous pouvez lui donner le nom qui vous plaît. Il faut seulement garder à l'esprit qu'il faut conserver cette variable (quel que soit son nom), c'est elle qui permettra d'accéder à la base de données avec les fonctions des chapitres suivants.

La syntaxe est simple :

La valeur renvoyée (rangée ici dans la variable $res) N'EST PAS le résultat de l'exécution de la requête, mais un identifiant (propre au système, sa valeur réelle ne nous intéresse pas) qui nous permettra d'accéder aux résultats grâce aux fonctions décrites ci-dessous.

peardb fournit deux fonctions pour traiter les lignes résultant d'une requête : fetchRow() et fetchInto().

La commande setfetchmode() configure le mode de récupération par défaut utilisé par les méthodes fetch*() (et get*()).

Nous ne l'utiliserons que deux manières (mais il en existe d'autres, allez voir la page qui lui est consacrée) :

Pour bien comprendre la différence vous pouvez utiliser la fonction PHP « print_r » (qui permet d'afficher un tableau en entier).

Ainsi ce programme

              $db->setfetchmode(DB_FETCHMODE_ORDERED);      // sortie en tableau ordonné
              $res =& $db->query("SELECT * FROM personne"); // une requête
              $res->fetchInto($row);                        // récupération de la 1ère ligne
              echo "<pre>";                                 // affichage « préformaté »
              print_r ($row);                               // affichage de la ligne en tableau
              echo "</pre>";                                // fin de  l'affichage « préformaté »

produira cet affichage

              Array
              (
                  [0] => 5
                  [1] => Kuzbidon
                  [2] => Ginette
                  [3] => 263
                  [4] => 393
                  [5] =>
                  [6] =>
                  [7] =>
              )

Tandis que celui-ci

              $db->setfetchmode(DB_FETCHMODE_ASSOC);        // sortie en tableau associatif
              $res =& $db->query("SELECT * FROM personne"); // une requête
              $res->fetchInto($row);                        // récupération de la 1ère ligne
              echo "<pre>";                                 // affichage « préformaté »
              print_r ($row);                               // affichage de la ligne en tableau
              echo "</pre>";                                // fin de  l'affichage « préformaté »

produira cet affichage

              Array
              (
                  [codepersonne] => 5
                  [nom] => Kuzbidon
                  [prenom] => Ginette
                  [numerodanslarue] => 263
                  [refrue] => 393
                  [tel] =>
                  [fax] =>
                  [email] =>
              )

On peut également utiliser les constantes DB_FETCHMODE_ORDERED et DB_FETCHMODE_ASSOC directement dans les fonctions fetchRow() et fetchInto()comme par exemple :

              $row =& $res->fetchRow(DB_FETCHMODE_ASSOC);

ou

              $res->fetchInto($row,DB_FETCHMODE_ORDERED);

Il y a quatre manières de récupérer des informations intéressantes des jeux de résultats.

Le module dbx est un module d'abstraction de base de données (db pour database (base de données) et 'X' pour toutes les bases supportées). Les fonctions dbx vous permettent d'accéder à toutes les bases supportées, avec la même convention. Les fonctions dbx elles-mêmes ne s'interfacent pas directement avec les bases de données, mais s'interfacent avec les modules utilisées pour supporter ces bases.

Pour pouvoir utiliser une base de données avec le module dbx, le module doit être soit lié, soit chargé dans PHP et le module de base de données doit être supporté par le module dbx. Actuellement les bases suivantes sont supportées, et d'autres suivront :

L'hétérogénéité des moyens d'accès aux bases de données a été un des problèmes les plus gênants en PHP. Le problème vient du fait que, par exemple, les fonctions permettant l'accès à une base PostgreSQL sont différentes de celles pour MySQL, et elles sont toutes différentes de celles pour SQLite, etc.

Cela a pour effet de rendre plus difficile la migration d'un système vers un autre : vous avez écrit (par exemple en cours) un site utilisant une base PostgreSQL et vous voulez le transférer chez un hébergeur qui n'offre que MySQL (Free, par exemple) : votre seule solution est de reprendre (et corriger) dans toutes vos pages tous les appels à des fonctions concernant PostgreSQL. Il peut y en avoir beaucoup...

Une couche d'abstraction^[5] permet d'éviter ce problème : tous vos accès à votre base de données passent par elle (avec la même syntaxe, quelle que soit la base de données) et c'est elle qui se débrouille pour s'adapter à la base de données utilisée. Pour changer de base de données (passer de PostgreSQL à MySQL par exemple) vous n'avez en général qu'à modifier une ligne, celle qui donne les paramètres de la base de données utilisée.

La première action, avant d'utiliser une base de données, est de s'y connecter.

Il suffit pour cela d'exécuter la commande

Le nom de la variable $db est sans importance. Ce n'est qu'une variable, vous pouvez lui donner le nom qui vous plaît. Il faut seulement garder à l'esprit qu'il faut conserver cette variable (quel que soit son nom), c'est elle qui permettra d'accéder à la base de données avec les fonctions des chapitres suivants.

Le type_de_base quant à lui est une valeur parmi DBX_MYSQL, DBX_ODBC, DBX_PGSQL, DBX_MSSQL, DBX_FBSQL, DBX_SYBASECT, DBX_OCI8, DBX_SQLITE.

La syntaxe est simple :

La valeur renvoyée (rangée ici dans la variable $res) N'EST PAS le résultat de l'exécution de la requête, mais un identifiant (propre au système, sa valeur réelle ne nous intéresse pas) qui nous permettra d'accéder aux résultats grâce aux fonctions décrites ci-dessous.

On peut facilement obtenir le nombre de lignes et de colonnes du résultat d'une requête de type SELECT :

              $result = dbx_query ($db, 'SELECT id FROM table');
              echo $result->rows; // nombre de lignes
              echo $result->cols; // nombre de champs

$result étant un résultat valide renvoyé par dbx_query(), $result->data est un tableau à 2 dimensions qui contient les résultats : le premier indice concerne les lignes, le deuxième concerne les colonnes.

              $result = dbx_query($db, "SELECT * FROM ville");
              foreach ( $result->data as $row ) {
                  echo $row["codepostal"]." - ".$row["ville"]."<br />\n";
              }

              $result = dbx_query($db, "SELECT * FROM ville");
              foreach ( $result->data as $row ) {
                  for ($i=0;$i<$result->cols;$i++) {
                      echo $row[$i]." ** ";
                  }
                  echo "<br />\n";
              }

              $result = dbx_query($db, "SELECT * FROM ville");
              for ($l=0;$l<$result->rows;$l++) {
                  for ($i=0;$i<$result->cols;$i++) {
                      echo $result->data[$l][$i]." ** ";
                  }
                  echo "<br />\n";
              }

Tous les exercices qui suivent sont à faire dans un répertoire qui contiendra des images (et d'autres choses aussi, pourquoi pas), ainsi qu'un sous-répertoire qui contiendra les mêmes images mais en réduction (en onglets, ou thumbnails en anglais).

Ces articles sont rangés chacun dans un fichier.

Le nom des fichiers est composé de trois parties :

On aura par exemple :

Chaque fichier contiendra du texte, sans codes HTML ni PHP. La première ligne devra obligatoirement être le titre de l'article.

Un des fichiers (inf004.jnl) contient par exemple :

        Xenux un site simple pour le débutant
        Xenux.fr.st est un nouveau site pour les pressés de Linux sans
        chichi sans blabla. On sait où on va dès le début de la lecture de
        l'article.
        Intéressant et ça marche..... 
        À Bientôt

Le site à réaliser aura les caractéristiques suivantes :

Si vous avez le temps vous pourrez également ajouter ces quelques fonctions à votre travail :

Pour utiliser des fichiers il faut savoir les écrire et les relire.

Nous allons réaliser un mini-site qui permet d'ajouter une ligne à la fois dans un fichier, tandis qu'une page permettra d'afficher le contenu du fichier.

Écrire un gestionnaire d'annuaire téléphonique.

Le minimum à atteindre :

Des améliorations possibles, qui ne seront prises en compte que ce qui précède est réalisé :

index.php :

        <html><body>
        <h1>News...</h1>
        <h2>Menu</h2>
        <ul>
        <li>liste des <a href="listenoms.php">noms</a> de fichiers de
           nouvelles</li>
        <li>liste des <a href="listeliens.php">liens</a> vers les fichiers de
           nouvelles</li>
        <li>affichage de <a href="affichetout.php">toutes les nouvelles</a></li>
        <li>affichage des <a href="affichetitre.php">titres</a> des nouvelles</li>
        <li>affichage des <a href="affichetitrelien.php">titres faisant</a>
           vers les nouvelles</li>
        <li>affichage de <a href="affichetout_br.php">toutes les nouvelles
           proprement</a></li>
        <li><a href="sujet.php">choix du sujet</a></li>
        </ul>
        </body></html>

listenoms.php :

        <html><body>
        <h1>News...</h1>
        <h2>Liste des noms de fichiers de nouvelles</h2>
        <ul>
        <?php
        $dir = opendir(".");
        while($file = readdir($dir)) {
          if (substr($file,-4)==".jnl") {
            echo "<li>$file;</li>\n";
          }
        }  
        closedir($dir);
        ?>
        </ul>
        </body></html>

listeliens.php :

        <html><body>
        <h1>News...</h1>
        <h2>Liste des liens vers les fichiers de nouvelles</h2>
        <ul>
        <?php
        $dir = opendir(".");
        while($file = readdir($dir)) {
          if (substr($file,-4)==".jnl") {
            echo "<li><a href=\"unenouvelle.php?f=$file\">$file</a></li>\n";
          }
        }  
        closedir($dir);
        ?>
        </ul>
        </body></html>

Cette page nécessite l'existence d'une page unenouvelle.php qui permet d'afficher le contenu d'une nouvelle:

        <html><body>
        <?php require($f);?>
        </body></html>

affichetout.php :

        <html><body>
        <h1>News...</h1>
        <h2>Affichage de toutes les nouvelles</h2>
        <hr />
        <?php
        $dir = opendir(".");
        while($file = readdir($dir)) {
          if (substr($file,-4)==".jnl") {
            $f=file($file);
            for ($i=0;$i<count($f);$i++) {
              echo $f[$i];
            }
          echo "<hr />";
          }
        }  
        closedir($dir);
        ?>
        </ul>
        </body></html>

affichetitre.php :

        <html><body>
        <h1>News...</h1>
        <h2>Affichage des titres des nouvelles</h2>
        <ul>
        <?php
        $dir = opendir(".");
        while($file = readdir($dir)) {
          if (substr($file,-4)==".jnl") {
            $f=file($file);
            echo "<li>$f[0]</li>\n";
          }
        }  
        closedir($dir);
        ?>
        </ul>
        </body></html>

affichetitrelien.php :

        <html><body>
        <h1>News...</h1>
        <h2>Affichage des titres faisant lien vers les nouvelles</h2>
        <ul>
        <?php
        $dir = opendir(".");
        while($file = readdir($dir)) {
          if (substr($file,-4)==".jnl") {
            $f=file($file);
            echo "<li><a href=\"$file\">$f[0]</a></li>\n";
          }
        }  
        closedir($dir);
        ?>
        </ul>
        </body></html>

Cette page nécessite l'existence de unenouvelle.php.

affichetout_br.php :

        <html><body>
        <h1>News...</h1>
        <h2>Affichage de toutes les nouvelles, proprement</h2>
        <hr />
        <?php
        $dir = opendir(".");
        while($file = readdir($dir)) {
          if (substr($file,-4)==".jnl") {
            $f=file($file);
            echo "<h3>$f[0]</h3>\n";
            for ($i=1;$i<count($f);$i++) {
              echo $f[$i];
              if (trim($f[$i])=="") {
                echo "<br />";
              }
            }
          echo "<hr />";
          }
        }  
        closedir($dir);
        ?>
        </body></html>

sujet.php :

        <html><body>
        <h1>News...</h1>
        <h2>Choix du sujet</h2>
        <form action="sujet2.php">
        <select name="sujet">
          <option value="sci">Sciences</option>
          <option value="inf">informatique</option>
          <option value="msc">Divers</option>
        </select>
        <input type="submit">
        </form>
        </body></html>

Vous allez devoir créer un site web qui gére le contenu d'une discothèque. Vous manipulerez des informations comme le nom des disques, leurs années de parution, les artistes, les textes des chansons, etc. Ces informations seront accessibles à d'autres personnes, vous devrez aussi gérer les droits d'accès à votre site web.

L'analyse ne sera pas présentée ici. Nous nous contenterons de donner la structure de la base.

MLD

Vous allez travailler pour Lille 3...

Lille 3 Numérique organise des stages de familiarisation des étudiants avec leur ENT. Il faut une application qui permette l'inscription des étudiants Lille 3 sur des créneaux horaires précis.

Vous allez leur venir en aide : c'est vous qui allez réaliser cette application.

L'analyse ne sera pas présentée ici. Nous nous contenterons de donner la structure de la base.

MLD

CREATE TABLE ufr (
            ufr_num INTEGER PRIMARY KEY,
            ufr_nom VARCHAR(40) NOT NULL
);

CREATE TABLE moniteur (
            mon_num INTEGER PRIMARY KEY,
            mon_nom VARCHAR(40) NOT NULL,
            mon_prenom VARCHAR(40)
);

CREATE TABLE salle (
            sal_num INTEGER PRIMARY KEY,
            sal_nom VARCHAR(40) NOT NULL,
            sal_taille INTEGER
);

CREATE TABLE niveau (
            niv_num INTEGER PRIMARY KEY,
            niv_nom VARCHAR(40) NOT NULL,
            niv_ordre INTEGER NOT NULL
);

CREATE TABLE seance (
            sea_num INTEGER PRIMARY KEY,
            sea_jour INTEGER NOT NULL,
            sea_mois INTEGER NOT NULL,
            sea_annee INTEGER NOT NULL,
            sea_debut_h INTEGER NOT NULL,
            sea_debut_m INTEGER NOT NULL,
            sea_fin_h INTEGER NOT NULL,
            sea_fin_m INTEGER NOT NULL,
            sea_moniteur INTEGER REFERENCES moniteur(mon_num),
            sea_salle INTEGER REFERENCES salle(sal_num),
            sea_remarque VARCHAR(200) DEFAULT ''
);

CREATE TABLE ville (
            vil_cp VARCHAR(10) PRIMARY KEY,
            vil_nom VARCHAR(40) NOT NULL
);

CREATE TABLE typevoirie (
            tvo_num INTEGER PRIMARY KEY,
            tvo_nom VARCHAR(40) NOT NULL
);

CREATE TABLE voirie (
            voi_num INTEGER PRIMARY KEY,
            voi_type INTEGER NOT NULL REFERENCES typevoirie(tvo_num),
            voi_nom VARCHAR(100) NOT NULL,
            voi_cp VARCHAR(6) NOT NULL REFERENCES ville(vil_cp)
);

CREATE TABLE etudiant (
            etu_carte VARCHAR PRIMARY KEY,
            etu_nom VARCHAR(40) NOT NULL,
            etu_prenom VARCHAR(40),
            etu_ufr INTEGER REFERENCES ufr(ufr_num),
            etu_niveau INTEGER REFERENCES niveau(niv_num),
            etu_adressenum VARCHAR(10),
            etu_voirie INTEGER NOT NULL REFERENCES voirie(voi_num),
            etu_email VARCHAR(40),
            etu_telfixe VARCHAR(20),
            etu_telmobile VARCHAR(20)
);

CREATE TABLE inscription (
            ins_etudiant VARCHAR(20) REFERENCES etudiant(etu_carte),
            ins_seance INTEGER REFERENCES seance(sea_num),
            PRIMARY KEY(ins_etudiant,ins_seance)
);

CREATE TABLE parametre (
            par_num INTEGER PRIMARY KEY,
            par_nom VARCHAR(20),
            par_texte VARCHAR(100),
            par_valeur VARCHAR(200),
            par_ordre INTEGER
);