Si les SGBD offrent les technologies de modélisation et de gestion des données, ils nécessitent la plupart du temps d'être interfacés avec des applications qui fournissent un accès orienté métier aux utilisateurs, notamment à travers des IHM évoluées. Même des systèmes comme Oracle ou PostgreSQL qui proposent un langage procédural (comme PL/SQL) au dessus de la couche SQL, ne sont pas auto-suffisants. Les langages évolués comme Java ou C++ sont couramment utilisés pour implémenter la couche applicative d'exploitation des BD.
Les applications de BD sont aujourd'hui généralement réalisées selon des architectures réseaux. L'explosion d'Internet de son côté a favorisé le langage HTML pour implémenter les IHM et a vu la naissance de langages de script pour implémenter la couche applicative côté serveur, tels que PHP ou JSP, plus simples que les langages classiques.
De nombreuses applications fonctionnent selon un environnement clients/serveur, cela signifie que des machines clientes (des machines faisant partie du réseau) contactent un serveur, une machine généralement très puissante en terme de capacités d'entrée-sortie, qui leur fournit des services. Ces services sont des programmes fournissant des données telles que l'heure, des fichiers, une connexion...
Les services sont exploités par des programmes, appelés programmes clients, s'exécutant sur les machines clientes. On parle ainsi de client FTP, client de messagerie...
Dans un environnement purement client/serveur, les ordinateurs du réseau (les clients) ne peuvent voir que le serveur, c'est un des principaux atouts de ce modèle.
Le modèle client/serveur est particulièrement recommandé pour des réseaux nécessitant un grand niveau de fiabilité, ses principaux atouts sont :
des ressources centralisées
étant donné que le serveur est au centre du réseau, il peut gérer des ressources communes à tous les utilisateurs, comme par exemple une base de données centralisée, afin d'éviter les problèmes de redondance et de contradiction
une meilleure sécurité
car le nombre de points d'entrée permettant l'accès aux données est moins important
une administration au niveau serveur
les clients ayant peu d'importance dans ce modèle, ils ont moins besoin d'être administrés
un réseau évolutif
grâce à cette architecture ont peu supprimer ou rajouter des clients sans perturber le fonctionnement du réseau et sans modifications majeures
L'architecture client/serveur a tout de même quelques lacunes parmi lesquelles :
un coût élevé
dû à la technicité du serveur
un maillon faible
le serveur est le seul maillon faible du réseau client/serveur, étant donné que tout le réseau est architecturé autour de lui! Heureusement, le serveur a une grande tolérance aux pannes (notamment grâce au système RAID)
Un système client/serveur fonctionne selon le schéma suivant:
Le client émet une requête vers le serveur grâce à son adresse et à son port, qui désigne un service particulier du serveur
Le serveur reçoit la demande et répond à l'aide de l'adresse de la machine client (et de son port)
L'architecture à deux niveaux (aussi appelée architecture 2-tier,tier signifiant étage en anglais) caractérise les systèmes clients/serveurs dans lesquels le client demande une ressource et le serveur la lui fournit directement. Cela signifie que le serveur ne fait pas appel à une autre application afin de fournir le service.
Dans l'architecture à 3 niveaux (appelée architecture 3-tier), il existe un niveau intermédiaire, c'est-à-dire que l'on a généralement une architecture partagée entre:
Le client
le demandeur de ressources
Le serveur d'application
(appelé aussi middleware) le serveur chargé de fournir la ressource mais faisant appel à un autre serveur
Le serveur secondaire
(généralement un serveur de base de données), fournissant un service au premier serveur
Étant donné l'emploi massif du terme d'architecture à 3 niveaux, celui-ci peut parfois désigner aussi les architectures suivantes :
Partage d'application entre client, serveur intermédiaire, et serveur d'entreprise
Partage d'application entre client, base de données intermédiaire, et base de données d'entreprise
L'architecture à deux niveaux est donc une architecture client/serveur dans laquelle le serveur est polyvalent, c'est-à-dire qu'il est capable de fournir directement l'ensemble des ressources demandées par le client.
Dans l'architecture à trois niveaux par contre, les applications au niveau serveur sont délocalisées, c'est-à-dire que chaque serveur est spécialisé dans une tâche (serveur web et serveur de base de données par exemple). Ainsi, l'architecture à trois niveaux permet :
une plus grande flexibilité/souplesse
une plus grande sécurité (la sécurité peut être définie pour chaque service)
de meilleures performances (les tâches sont partagées)
Dans l'architecture à 3 niveaux, chaque serveur (niveaux 1 et 2) effectue une tâche (un service) spécialisée. Ainsi, un serveur peut utiliser les services d'un ou plusieurs autres serveurs afin de fournir son propre service. Par conséquence, l'architecture à trois niveaux est potentiellement une architecture à N niveaux.
Fait à partir de www.commentcamarche.net. Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
Un serveur web est un logiciel permettant à des clients d’accéder à des pages web, c'est-à-dire en réalité des fichiers au format HTML à partir d'un navigateur.
Un serveur web est donc un "simple" logiciel capable d'interpréter les requêtes HTTP arrivant sur le port associé au protocole HTTP (par défaut le port 80), et de fournir une réponse avec ce même protocole.
Les principaux serveurs web sur le marché sont entre autres :
Apache
Microsoft IIS (Internet Information Server)
...
Fait à partir de www.commentcamarche.net. Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
On appelle une architecture LAPP une architecture qui s'appuie sur :
Linux pour le système d'exploitation
Apache pour le serveur Web
PostgreSQL pour la base de données
PHP pour le langage applicatif
LAMP : Linux, Apache, MySQL, PHP
WAMP : Windows, Apache, MySQL, PHP
...
Cette section a été réalisée à partir de contenus de www.commentcamarche.net, © 2003 Jean-François Pillou (document soumis à la licence GNU FDL).
Comprendre les principes des architectures d'application de bases de données (en particulier 3-tier et Web)
Savoir appliquer les principes d'une architecture Web dans le cadre des technologies Servlets ou PHP et HTML
Quelle sont les atouts d'une architecture 3-tier par rapport à une architecture client-serveur classique ?
Qu'est ce qu'une architecture Web ?
Les comptes d'UV sont des comptes sur des serveurs Linux de l'UTC (accès et espace disque réservé). Par exemple nf17p001 est un compte sur le serveur tuxa.sme.utc.
Les comptes d'UV sont également des comptes d'accès sur des postes clients Linux ou Windows de l'UTC.
Les clients Windows de l'UTC sont configurés pour proposer un disque virtuel Z qui pointe sur l'espace du serveur Linux : les données déposées sur le disque Z sont donc physiquement stockées sur le serveur Linux.
Les clients Linux de l'UTC sont configurés pour que le dossier home sur le client corresponde à un répertoire sur le serveur.
Quelque soit le client il est possible d'utiliser un client SFTP (Filezilla par exemple) en se connectant au serveur (par exemple tuxa.sme.utc) avec son compte UTC (par exemple nf17p001).
Pour se connecter à un serveur Linux depuis un client Windows on peut utiliser le terminal par défaut du système, mais il est recommandé d'utiliser un programme plus performant comme par exemple Putty.
Ouvrez un terminal :
Exécuter Putty.
Connectez-vous sur votre compte Linux :
Connectez vous de préférence en utilisant ssh, lancez ssh username@tuxa.sme.utc dans le terminal Putty (avec username votre compte NF17).
Pour se connecter depuis une machine Windows vers un serveur Linux, on utilise le client Putty pour se connecter avec le protocole ssh.
cd
man
ls
pwd
chmod
more
...
Les fichiers HTML sont mis dans un dossier ~/public_html
Il faut donner les droits en lecture sur les fichiers (chmod 755)
Les fichiers sont ensuite accessibles sur le Web via une adresse telle que :
http://tuxa.sme.utc/~nf17pXXX/monfichier.html
PostgreSQL est :
un SGBDRO
libre (licence BSD)
multi-plate-formes (Unix, Linux, Windows, MacOS, ...)
puissant (proche d'Oracle)
très respectueux du standard
numériques : integer (int2, int4, int8), real (float4, float8)
dates : date (time, timestamp)
chaînes : char, varchar, text
autres : boolean, array[]
Voir Identification d'objets et références
Voir Les types utilisateurs
psql est le client textuel de PostgreSQL.
psql dbname -h host
\? : Liste des commandes psql
\h : Liste des instructions SQL
\h CREATE TABLE : Description de l'instruction SQL CREATE TABLE
\q : Quitter psql
\d : Liste des relations (catalogue de données)
\d maTable : Description de la relation maTable
\H : mode HTML ou mode textuel pour les retours de requête
\! : permet d'exécuter certaines commandes du shell Linux
Une instruction SQL peut s'écrire sur une ou plusieurs lignes, le retour chariot n'a pas d'incidence sur la requête, c'est le ; qui marque la fin de l'instruction SQL et provoque son exécution.
dbnf17p015=> SELECT * FROM maTable ;
dbnf17p015=> SELECT * dbnf17p015-> FROM maTable dbnf17p015-> ;
On notera dans psql la différence entre les caractères => et -> selon que l'on a ou pas effectué un retour chariot.
Il est souvent intéressant d'exécuter un fichier contenant une liste de commandes SQL, plutôt que de les entrer une par une dans le terminal. Cela permet en particulier de recréer une base de données à partir du script de création des tables.
Pour exécuter un fichier contenant du code SQL utiliser la commande PostgreSQL \i chemin/fichier.sql
chemin désigne le répertoire dans lequel est le fichier fichier.sql
le dossier de travail de psql est le dossier dans lequel il a été lancé, le script peut être lancé à partir de son dossier home pour en être indépendant (~/.../fichier.sql)
CSV est un format informatique permettant de stocker des données tabulaires dans un fichier texte.
Chaque ligne du fichier correspond à une ligne du tableau. Les valeurs de chaque colonne du tableau sont séparées par un caractère de séparation, en général une virgule ou un point-virgule. Chaque ligne est terminée par un caractère de fin de ligne (line break).
Toutes les lignes contiennent obligatoirement le même nombre de valeurs (donc le même nombre de caractères de séparation). Les valeurs vides doivent être exprimées par deux caractères de séparation contigus.
La taille du tableau est le nombre de lignes multiplié par le nombre de valeurs dans une ligne.
La première ligne du fichier peut être utilisée pour exprimer le nom des colonnes.
[NomColonne1;NomColonne2;...;NomColonneN] ValeurColonne1;ValeurColonne2;...;ValeurColonneN ValeurColonne1;ValeurColonne2;...;ValeurColonneN ...
Pierre;Dupont;20;UTC;NF17 Pierre;Dupont;20;UTC;NF26 Paul;Durand;21;UTC;NF17 Jacques;Dumoulin;21;UTC;NF29
Prenom;Nom;Age;Ecole;UV Pierre;Dupont;20;UTC;NF17 Pierre;Dupont;20;UTC;NF26 Paul;Durand;21;UTC;NF17 Jacques;Dumoulin;21;UTC;NF29
Jacques;Dumoulin;;UTC;NF29
L'âge est inconnu (NULL).
La syntaxe des fichiers CSV n'est pas complètement standardisée, aussi des variations peuvent exister :
Les chaînes de caractères peuvent être protégées par des guillemets (les guillemets s'expriment alors avec un double guillemet).
Le caractère de séparation des nombres décimaux peut être le point ou la virgule (si c'est la virgule, le caractère de séparation doit être différent)
...
Un des problème les plus importants reste l'encodage des caractères qui n'est pas spécifié dans le fichier et peut donc être source de problèmes, lors de changement d'OS typiquement.
Les fichiers CSV sont très utilisés en BD pour échanger les données d'une table (export/import).
Les SGBD contiennent généralement des utilitaires permettant d'exporter une table ou un résultat de requête sous la forme d'un fichier CSV, en spécifiant un certain nombre de paramètres (caractère de séparation de valeur, caractère de fin de ligne, présence ou non d'une ligne de définition des noms des colonnes, etc.). De même ils proposent des utilitaires permettant d'importer un fichier CSV dans une table (en spécifiant les mêmes paramètres), voire de créer directement une table à partir du fichier CSV (quand les noms des colonnes sont présents).
Les fichiers à largeur de colonne fixe n'utilisent pas de séparateur de colonne, mais imposent le même nombre de caractères pour chaque cellule. L'avantage est de ne pas avoir à spécifier le caractère de séparation, l'inconvénient est la taille de fichier supérieure si les valeurs ne font pas toutes la même largeur.
Les fichiers XML tendent de plus en plus à remplacer les fichiers CSV car ils permettent d'être beaucoup plus expressifs sur le schéma d'origine. Ils sont également plus standards (encodage spécifié, principe de séparation des données par les tags, etc.). Leur seul inconvénient est d'être plus verbeux et donc plus volumineux.
Certains SGBD, comme Oracle, permettent de créer des tables dites externes, qui autorisent de créer un schéma de table directement sur un fichier CSV, permettant ainsi un accès SQL standard à un fichier CSV, sans nécessité de l'importer d'abord dans une table.
\copy nom_table (att1, att2, ...) FROM 'fichier.csv' WITH CSV DELIMITER ';' QUOTE '"'
WITH introduit les options de l'import
CSV indique qu'il s'agit d'un fichier CSV
DELIMITER 'c' indique que le caractère c est utilisé comme délimiteur de champ (en général ; ou ,)
QUOTE 'c' indique que le caractère c est utilisé comme délimiteur de chaîne (en général ")
La table nom_table doit déjà exister
Le nombre de colonnes spécifié doit correspondre au nombre de colonnes du fichier CSV
Les types doivent être compatibles
Ajouter l'option HEADER après WITH CSV si le fichier CSV contient une ligne s'entête.
\copy nom_table (att1, att2, ...) FROM 'fichier.csv' WITH CSV HEADER DELIMITER ';' QUOTE '"'
Par défaut, la commande \copy prendra le chemin du répertoire courant au moment où la commande psql a été lancée.
Sous psql, vous pouvez utiliser les commandes :
dbnf17p007=> \! pwd
Pour exécuter la commande shell pwd et obtenir le répertoire courant
dbnf17p007=> \cd directory
Pour changer le répertoire courant
Un client graphique une interface graphique permettant d'effectuer les mêmes opérations qu'avec le client psql.
Le client graphique pgAdminIII est un client lourd qui fonctionne très bien sous Linux, mais qui est instable sous Windows.
Le client graphique phpPgAdmin est un client léger (qui tourne dans un navigateur Web donc).
Sélectionner Fichier > Ajouter un serveur
Utilisez votre compte et mot de passe NF17
Hôte : tuxa.sme.utc
Port : 5432 (port standard de PostgreSQL)
Base : dbnf17p...
Nom : nf17p...
Mot de passe : ...
Sélectionner sa base de données dans la liste Bases de données
Sélectionner Outils > Éditeur de requêtes (ou CTRL+E)
CREATE SCHEMA myschema;
CREATE TABLE myschema.mytable ( ... );
SELECT ... FROM myschema.mytable
Afin d'alléger la syntaxe il est possible de définir un schéma par défaut, dans lequel seront créer les tables non-préfixées et un ou plusieurs schémas par défaut dans lesquels seront requêtées les tables non-préfixées.
SET search_path TO myschema,public;
Cette instruction définit le schéma myschema comme schéma par défaut pour la création de table et le requêtage, puis public pour le requêtage, le premier étant prioritaire sur le second :
CREATE mytable créera ma mytable dans le schéma mychema.
SELECT FROM mytable cherchera la table dans la schéma mychema, puis dans le schéma public si la table n'existe pas dans le premier schéma.
Le schéma public est un schéma créé par défaut à l'initialisation de la base, et qui sert de schéma par défaut en l'absence de toute autre spécification.
http://www.postgresql.org/docs/current/static/sql-createtable.html
PL/Tcl
PL/Perl
PL/Python
...
http://www.postgresql.org/docs/current/static/xplang.html
http://www.postgresql.org/docs/current/static/server-programming.html
HTML est un langage inventé à partir de 1989 pour coder des pages de contenu sur le Web. Il est standardisé par le W3C.
HTML est un langage à balises : il se fonde sur le mélange entre du contenu et des balises permettant de caractériser ce contenu. HTML utilise le formalisme SGML pour définir les balises et combinaisons de balises autorisées.
<p>Ceci est un contenu, caractérisé par des <b>balises</b></p>
Les balises p et b ont une signification dans le langage HTML : Créer un paragraphe et mettre en gras.
La version courante de HTML et la version 4.01 de 1999. Le HTML5 en cours de spécification est déjà dans un état avancé de spécification et d'implémentation, il peut d'ors et déjà être employé et est prévu pour 2014.
XHTML est une réécriture du HTML : tandis que HTML est fondé sur SGML, XHTML est fondé sur XML, plus récent et plus rigoureux. XHTML et HTML ne présentent pas de différence fonctionnelle, uniquement des différences syntaxiques.
<ul><li>Ceci est un extrait de contenu <i>HTML
<ul><li>Ceci est un extrait de contenu <i>XHTML</i></li></ul>
Dans le cas du HTML les balises fermantes sont optionnelles, en XHTML c'est obligatoire. Les deux exemples sont donc équivalents, mais dans l'exemple HTML, il existait en fait plusieurs interprétations possibles, par exemple :
<ul><li>Ceci est un extrait de contenu</li></ul><i>XHTML</i>
La version actuelle de XHTML est la version 1, correspondant à HTML4. XHTML5 est le pendant de HTML5.
Définition du XML
Historique : de SGML à XML
Discussion : HTML et XML
<html xmlns="http://www.w3.org/1999/xhtml"> <head> ... </head> <body> ... </body> </html>
<head> <title>...</title> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> </head>
<body> <h1>...</h1> <h2>...</h2> <p>...</p> </body>
Tutoriel XHTML : http://fr.html.net/tutorials/html/
Brillant07, pp107-108
<p>Un paragraphe de texte</p> <p>Paragraphe contenant du texte, mot <b>gras</g> ou <i>italique</i>.</p> <p><a href="page02.html">Un lien</a> vers une autre page</p> <img src="img.png" alt="une image"/> <h1>Titre de niveau 1</h1> <h2>Titre de niveau 2</h2> <h3>Titre de niveau 3</h3> <table border="1"> <tr><th>Titre colonne 1</th><th>Titre colonne 2</th><th>...</th></tr> <tr><td>Ligne 1 colonne 1</td><td>Ligne 1 colonne 2</td><td>...</td></tr> <tr><td>Ligne 2 colonne 1</td><td>Ligne 2 colonne 2</td><td>...</td></tr> </table> <ul> <li>Item de liste à puce</li> <li>Item de liste à puce</li> </ul> <ol> <li>Item de liste à ordonnée</li> <li>Item de liste à ordonnée</li> </ol>
Pour une description des balises de base : Brillant07, pp108-112.
Fait à partir de www.commentcamarche.net. Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
Grâce à la balise FORM du langage HTML, il est très simple de créer des formulaires comprenant :
des cases à cocher
des champs de saisie
des boutons radio
des listes à choix multiples
...
<form Method="GET" Action="test.php"> Nom : <input type="text" name="nom"><br/> Prénom : <input type="text" name="prenom"><br/> Age : <input type="text" name="age"><br/> <input type="submit"> </form>
CSS (Cascading Style Sheets) est un standard du W3C qui complète HTML.
CSS sert à :
Mieux séparer méthodologiquement la structure (en HTML) de la mise en forme (CSS)
Simplifier l'écriture HTML (et la génération HTML dans le cas de sites dynamiques réalisés avec PHP par exemple)
Factoriser et réutiliser la mise en forme, notamment pour assurer l'homogénéisation d'un site Web (externalisation des feuilles CSS)
Augmenter les possibilités de mise en forme du HTML (couches CSS)
On peut associer à tout fichier HTML, dans le head, une ou plusieurs feuilles CSS (qui se complètent "en cascade").
<html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <title>...</title> <link href='css/style1.css' type='text/css' rel='stylesheet'/> <link href='css/style2.css' type='text/css' rel='stylesheet'/> ...
Un fichier CSS permet d'associer une mise en forme aux éléments utilisés dans le fichier HTML.
p { font-family:sans-serif;}
On peut différencier les styles en fonction des attributs class et id des éléments HTML.
On recours alors massivement aux éléments div et span pour le stylage, avec des attributs id (pour référencer un élément particulier) et/ou class (pour référencer un ensemble d'éléments de même type).
div.class { ... } span.class { ... } #id { ... }
Tutoriel CSS didactique et complet : http://fr.html.net/tutorials/css/.
Pour une introduction à CSS : Brillant07, pp112-122.
Zen Garden : http://www.csszengarden.com/ ; Le Zen des CSS
+ ref
+ explications générales GET / POST
CF SR03
Savoir écrire une page simple en HTML
Savoir créer des formulaires en HTML
A quoi sert un formulaire en HTML ?
PHP est un langage interprété (un langage de script) exécuté du côté serveur (comme les scripts CGI, ASP, ...) et non du côté client (un script écrit en JavaScript ou une applet Java s'exécute au contraire sur l'ordinateur où se trouve le navigateur). La syntaxe du langage provient de celles du langage C, du Perl et de Java.
Ses principaux atouts sont :
La gratuité et la disponibilité du code source (PHP est distribué sous licence GNU GPL)
La simplicité d'écriture de scripts
La possibilité d'inclure le script PHP au sein d'une page HTML (contrairement aux scripts CGi, pour lesquels il faut écrire des lignes de code pour afficher chaque ligne en langage HTML)
La simplicité d'interfaçage avec des bases de données (de nombreux SGBD sont supportés, le plus utilisé avec ce langage est MySQL).
L'intégration au sein de nombreux serveurs web (Apache...)
MySQL
Oracle
PostgreSQL
...
Un script PHP est un simple fichier texte contenant des instructions écrites à l'aide de caractères ASCII 7 bits (des caractères non accentués) incluses dans un code HTML à l'aide de balises spéciales et stocké sur le serveur. Ce fichier doit avoir une extension particulière (qui dépend de la configuration du serveur HTTP, en général ".php") pour pouvoir être interprété par le serveur.
Ainsi, lorsqu'un navigateur (le client) désire accéder à une page dynamique réalisée en php :
Le serveur reconnaît qu'il s'agit d'un fichier PHP
Il lit le fichier PHP
Dès que le serveur rencontre une balise indiquant que les lignes suivantes sont du code PHP, il "passe" en mode PHP, ce qui signifie qu'il ne lit plus les instructions: il les exécute.
Lorsque le serveur rencontre une instruction, il la transmet à l'interpréteur
L'interpréteur exécute l'instruction puis envoie les sorties éventuelles au serveur
A la fin du script, le serveur transmet le résultat au client (le navigateur)
Un script PHP est interprété par le serveur, les utilisateurs ne peuvent donc pas voir le code source !
Le code PHP stocké sur le serveur n'est donc jamais visible directement par le client puisque dès qu'il en demande l'accès, le serveur l'interprète ! De cette façon aucune modification n'est à apporter sur les navigateurs...
Pour que le script soit interprété par le serveur deux conditions sont nécessaires :
Le fichier contenant le code doit avoir l'extension .php et non .html (selon la configuration du serveur Web)
Le code PHP contenu dans le code HTML doit être délimité par les balises "<?php" et "?>"
<html> <head><title>Exemple</title></head> <body> <?php echo "Hello world"; ?> </body> </html>
Tutoriel PHP : http://fr.html.net/tutorials/php/
<?php $i=0 ; while($i<6) { echo $i ; $i=rand(1,6) ; }
Une instruction se termine par un ;
Les espaces, retours chariot et tabulation ne sont pas pris en compte par l'interpréteur
Les commentaires sont écrits entre les délimiteurs /* et */ ou // sur une seule ligne.
Le langage est case-sensitive (sauf pour les fonctions).
Eclipse PDT (PHP Development Tools)
Zend Studio
Les variables ne sont pas déclarées
Les variables commencent pas un $
Les variables ne sont pas typées
Les variables en langage PHP peuvent être de trois types :
Scalaires (entiers, chaîne, réels)
Tableaux (un tableau pouvant être multidimensionnel et stocker des scalaires de types différents)
Tableaux associatifs (indexés par des chaînes)
$Entier=1; $Reel=1.0; $Chaine="1"; $Tableau[0]=1 $Tableau[1]="1" $TableauMulti[0][0]="1.0" $TableauAssoc[Age]=18
if (isset($var)) { echo $var; }
La fonction isset() permet de tester qu'une variable existe et est affectée.
if (condition réalisée) { liste d'instructions } elseif (autre condition réalisée) { autre série d'instructions } ... else (dernière condition réalisée) { série d'instructions }
for (compteur; condition; modification du compteur) { liste d'instructions }
while (condition réalisée) { liste d'instructions }
function Nom_De_La_Fonction(argument1, argument2, ...) { liste d'instructions ... return valeur_ou_variable; ... }
echo Expression;
La fonction print est iso-fonctionnelle avec echo et printf plus complexe permet en plus le formatage des données (peu utilisée).
Le code PHP peut être implanté au sein du code HTML. Cette caractéristique n'est pas à négliger car le fait d'écrire uniquement du code PHP là où il est nécessaire rend la programmation plus simple (il est plus simple d'écrire du code HTML que des fonctions echo ou print, dans lesquelles les caractères spéciaux doivent être précédés d'un antislash sous peine de voir des erreurs lors de l'exécution).
L'exemple le plus simple concerne les pages dynamiques dont l'en-tête est toujours le même: dans ce cas, le code PHP peut ne commencer qu'à partir de la balise <body>, au moment où la page peut s'afficher différemment selon une variable par exemple.
Mieux, il est possible d'écrire plusieurs portions de script en PHP, séparées par du code HTML statique car les variables/fonctions déclarées dans une portion de script seront accessibles dans les portions de scripts inférieures.
PHP rend très simple la récupération de données envoyées par l'intermédiaire de formulaires HTML.
Lorsque l'on soumet un formulaire à un fichier PHP, toutes les données du formulaire lui sont passées en tant que variables, c'est-à-dire chacun des noms associés aux champs (ou boutons) du formulaire précédés du caractère $.
<html> <body> <form method="GET" action="test.php"> <input type="text" size="20" name="MaVar"/> <input type="submit"/> </form> </body> </html>
<?php echo $MaVar; ?>
Selon la configuration du module PHP, il est possible que la récupération directe des données issue du formulaire HTML ne fonctionne pas. On peut dans ce cas utiliser les tableaux associatifs $HTTP_GET_VARS['variable'] et $HTTP_POST_VARS['variable'] ou $_GET['variable'] et $_POST['variable'] (selon configuration).
<?php $MaVarLocale=$HTTP_GET_VARS['MaVar'] echo $MaVarLocale; ?>
La page retournée dans l'exemple n'est pas du HTML (mais du simple texte qu'un navigateur peut néanmoins afficher). Pour retourner du HTML, il faut implanter ce même code au sein d'une page HTML.
<html> <body> <?php echo $MaVar; ?> </body> </html>
Les navigateurs disposent d'un cache, c'est à dire d'une copie locale des fichiers qui leur évite de recharger plusieurs fois un fichier identique. Lorsque l'on développe une application PHP, les fichiers changent fréquemment, il est alors nécessaire de vider le cache pour que le navigateur recharge bien la nouvelle version du code.
Sous Firefox, faire CTRL+F5.
Cette section a été réalisée avec l'aide de contenus issus de www.commentcamarche.net, © 2003 Jean-François Pillou (document soumis à la licence GNU FDL).
Comprendre le fonctionnement d'un langage applicatif côté serveur comme PHP
Savoir faire des programmes simples en PHP
Savoir faire communiquer un serveur PHP avec un client HTML
Comment se situe PHP dans une architecture Web ?
Pourquoi un langage comme PHP s'est-il développé ces dernières années à votre avis ?
Quels inconvénients peut-on trouver à un langage comme PHP ?
$vConn = pg_connect("host=$vHost port=$vPort dbname=$vDbname user=$vUser password=$vPassword");
$vSql ="SELECT ..."; $vQuery=pg_query($vConn, $vSql); while ($vResult = pg_fetch_array($vQuery, null, PGSQL_ASSOC)) { ... $vResult[nom_attribut]... }
$vSql="INSERT ..."; $vQuery=pg_query($vConn, $vSql);
pg_close($conn)
Fait à partir de http://www.php.net/manual/en/ref.oci8.php.
L'API OCI a remplacé l'ancienne API ORA (qui n'est plus supportée dans PHP).
oci_connect établit une connexion entre le serveur PHP et un serveur Oracle.
connection_id oci_connect(string username, string password, string bd);
if (! $conn=oci_connect($user, $passwd, $bd)) { echo "Impossible d'établir la connexion "; exit; }
oci_parse analyse une requête SQL et retourne un pointeur sur un statement (espace de requête).
statement_handle oci_parse(connection_id connection, string query);
if(! $statement=oci_parse($conn, $sql)) { echo "Impossible de préparer la requête"; exit; }
oci_execute exécute une commande déjà préparée avec OCIParse. Il est possible de spécifier le mode d'exécution des transactions (par défaut, il est en auto-commit, c'est à dire que l'ordre commit est passé automatiquement après chaque instruction SQL). Il est préférable d'utiliser le mode OCI_DEFAULT qui permet de contrôler les commits.
boolean oci_execute(statement_handle statement, int mode);
$mode permet de paramétrer le commit (par défaut, le commit est envoyé automatiquement si l'exécution est correcte).
if(! oci_execute($statement, OCI_DEFAULT)) { echo "Impossible d'exécuter la requête"; exit; }
oci_commit valide la transaction en cours sur une connexion.
boolean oci_commit(connection_id connection);
if(! oci_commit($conn)) { echo "Impossible de valider la transaction"; exit; }
oci_rollback permet d'annuler une transaction.
oci_fetch_array retourne la ligne suivante (pour une instruction SELECT) dans un tableau à une dimension (il écrasera le contenu du tableau s'il existe). Par défaut, le tableau sera un tableau à double index, numérique et associatif.
array oci_fetch_array(statement_handle statement)
while ($row=oci_fetch_array($statement)) { echo $results[0]; echo $results[1]; ... }
oci_close ferme une connexion Oracle.
boolean oci_close(connection_id connection);
if (! oci_close($conn)) { echo "Impossible de fermer la connexion "; exit; }
Fait à partir de www.commentcamarche.net. Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
Complété à partir de MySQL 4 : Installation, mise en oeuvre et programmation.
mysql_connect($host,$user,$passwd);
mysql_select_db($bdd);
$result=mysql_query($query)
/* Test d'exécution de la requête */ if (! mysql_fetch_row($result)) { echo "Aucun enregistrement ne correspond\n"; } else { while($row = mysql_fetch_row($result)) { ... $row[1] ... $row[2] ... } }
mysql_close();
Comprendre le rôle des langages applicatifs (PHP par exemple) comme sur-couche au dessus des SGBD et SQL
Savoir accéder à une base de données depuis un programme PHP
A quoi sert une API PHP d'accès à une base de données ?
Une variable de session PHP est une variable stockée sur le serveur.
C'est une variable temporaire qui a une durée limitée et est détruite à la déconnexion (fermeture du navigateur).
Les variables de session sont partagées par toutes les pages PHP d'une session (accès depuis un même navigateur). Elles permettent donc le passage d'information entre pages.
Sauvegarde d'identifiants de connexion
Sauvegarde d'un panier d'achat
...
<?php session_start(); ?>
Ce code est à placer au début de toutes les pages PHP qui souhaitent utiliser les variables de sessions, avant tout autre code PHP ou HTML.
<?php ... $_SESSION['variable'] = valeur ; ... ?>
<?php // page1.php session_start(); ?> <html> <body> <h1>Page 1</h1> <?php $_SESSION['login'] = 'me'; $_SESSION['mdp'] = 'secret'; ?> <a href="page2.php">page 2</a> </body> </html>
<?php // page2.php session_start(); ?> <html> <body> <h1>Page 2</h1> <?php echo $_SESSION['login'] ; echo "<br/>" ; echo $_SESSION['mdp'] ; ?> </body> </html>
La page page2.php est en mesure d'afficher les informations de la page page1.php.
Supprimer une variable : unset($_SESSION['variable'])
Supprimer toutes les variables : session_unset()
Supprimer la session : session_destroy()
Les sessions s'appuient sur les cookies, fichiers de données gérés côté client par le navigateur Web, pour stocker l'identifiant de session. Il est possible d'utiliser des sessions sans cookie, en passant l'identifiant de session dans l'URL.
class NomClasse { // Déclarations des attributs public $donneeMembre1; public $donneeMembre2; ... // Déclarations du constructeur function __construct () { ... } // Déclarations des méthodes public function Nom_de_la_fonction_membre1(parametres) { ... } ... }
Le mot clé $this permet d'accéder à l'objet en cours lors de la déclaration des méthodes.
$Nom_de_l_objet = new Nom_de_la_classe;
$Nom_de_l_objet->Nom_de_la_propriété = Valeur;
$Nom_de_l_objet->Nom_de_la_méthode (parametre1,parametre2,...);
<?php class Connect { var $fHost; var $fPort; var $fDbname; var $fUser; var $fPassword; var $fConn; function __construct () { $this->fHost="foo.fr"; $this->fPort="5432"; $this->fDbname="myDb"; $this->fUser="Me"; $this->fPassword="Secret"; } function mConnect () { $this->fConn = pg_connect("host=$this->fHost port=$this->fPort dbname=$this->fDbname user=$this->fUser password=$this->fPassword") or die('Échec de la connexion : ' . pg_last_error()); } function mClose () { pg_close($this->fConn); } } ?>
<?php include "connect_class.php"; $vConnect = new Connect; $vConnect->mConnect(); ?>
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.
PHP précis et concis
Une référence très rapide et pratique à utiliser sur PHP.
HTTP précis et concis
Petite référence pour comprendre rapidement les bases du protocole HTTP.
Apache précis et concis
Petite référence pour configurer un serveur Apache.
Dans la première partie vous vous attacherez à la partie base de données, en utilisant PostgreSQL. Dans la seconde partie vous vous attacherez à la partie application en PHP et interface graphique en HTML.
Pensez à utiliser des documentations de PostgreSQL, par exemple :
Proposez un bilan rapide de votre modélisation et des points importants pour l'implémentation de l'application.
Proposez un bilan rapide des aspects faciles et difficiles de PHP.
Réaliser une application PHP pour exploiter une base de données
Utiliser PostgreSQL
Faites la synthèse de votre travail en reprenant les points méthodologiques les plus importants.