Vader[FR] : ce n'est pas un blog, c'est un Sith

Fonctions pour PDO

Vader[FR] — 2018-07-01T10:29:46Z

PDO est une couche d'abstraction en PHP permettant d'adresser une base de données indépendamment de son type (MySQL, PostGres, Oracle...)
Par sécurité, il est préférable de faire des requêtes paramétrées afin d'éviter l'injection SQL.
Le contrecoup, c'est le rajout de code qui devient plus long à écrire.

Le code étant toujours le même, il est toutefois possible de le simplifier en créant une fonction simple qu'il suffira d'appeler.

Cette première fonction permet de préparer et exécuter une requête, laquelle peut être paramétrée, et dont le résultat pourra être :

plusieurs lignes, traitées ensuite dans une boucle foreach
un nombre de ligne modifié

Elle effectue donc un prepare, puis bindValue pour 0-n paramètres, puis un execute, et renvoie l'objet requête PDO.
les paramètres de la requêtes sont fournis dans un tableau qui commence à 1 (de préférence) ou zéro
la requête doit donc avoir " ?" en paramètre(s) afin de pouvoir les affecter depuis un tableau par indice, plus facilement traitable. voir l'exemple plus bas

function prepexec($rek,$params,$db){ if (isset($params[0])){ $debut=0; $correc=1; $fin=sizeof($params)-1; }else{ $debut=1; $correc=0; $fin=sizeof($params); } $rk=$db->prepare($rek); // si tableau param vide, pas de bindValue => fonction unique prepare avec/sans param + exec for ($i=$debut;$i<=$fin;$i++){ $typ_param=PDO::PARAM_STR;// PAR DEFAUT $param=$params[($i+$correc)]; if (preg_match("/[\w]+/",$param)){ $typ_param=PDO::PARAM_STR; } // PDO::PARAM_STR if (preg_match("/^[+-]?\d+$/",$param)){ $typ_param=PDO::PARAM_INT; } // PDO::PARAM_INT // PDO::PARAM_BOOL - MySQL might not support PARAM_BOOL if (preg_match("/^$/",$param)){ $typ_param=PDO::PARAM_NULL; } // PDO::PARAM_NULL $rk->bindValue($i,$param,$typ_param); } // renvoie la requête préparée et executée $rk->execute(); // $nb=$rk->execute(); OU foreach ($rk as $result){ // donc $nb=prepexec(... ou $rk=prepexec puis foreach($rk... ou même foreach(prepexec... return $rk; }

exemple d'appel :

 $rek="select count(login) as existe from utilisateur where login=?"; $params[1]=$user; $rk=prepexec($rek,$params,$db); $existe=0; foreach ($rk as $result){ $existe=$result['existe']; }

Cependant, cela est encore trop long.
Cette deuxième fonction va donc faire le boulot en appelant la première et en renvoyant la valeur attendue, unique, et dont le nom du champ est indiqué.

function simplexec($rek,$params,$db,$nomvar){ $resultat=null; $rk=prepexec($rek,$params,$db); foreach ($rk as $result){ $resultat=$result["$nomvar"]; } return $resultat; }

Fonctions sur les mots de passe

Vader[FR] — 2018-07-01T10:27:49Z

Diverses fonctions pour gérer l'authentification d'utilisateurs et le stockage sécurisé des mots de passe dans la BDD.

Vérification de la complexité d'un mot de passe

si la fonction renvoie une chaîne vide lorsqu'on l'appelle, tout baigne.

function chk_complex_mp($motpass){ $message=""; $patterns[0]="/^.*[A-Z].*+$/";	$complexe[0]="Il faut au moins une lettre majuscule
"; $patterns[1]="/^.*[a-z].*+$/";	$complexe[1]="Il faut au moins une lettre minuscule
"; $patterns[2]="/^.*[0-9].*+$/";	$complexe[2]="Il faut au moins un chiffre
"; $patterns[3]="/^.{8,}$/"; $complexe[3]="Il faut au moins 8 caractères
"; for ($i=0;$i

`Hashage de mot de passe avec sel, par algorithme choisi`


Cette fonction n'est qu'un exemple de fonction de cryptage, il est possible de faire plus souple/plus complexe.

A partir d'un mot de passe en clair, d'une chaîne de salage et d'un algorithme de hashage, elle :
 casse le sel en 3 parties de 10 caractères
 casse le mot de passe en 3 parties égales
 hash une première fois les morceaux de mot de passe mélangés aux morceaux de sel
 re-casse le mot de passe salé et hashé en 3 parties égales
 et enfin re-mélange le sel avec le mot de passe hashé.
function genere_motpasse($motpasse,$alt,$algo){ $alt1=substr($alt, 0, 10); $alt2=substr($alt, 10, 10); $alt3=substr($alt, 20, 10); $taillepass=strlen($motpasse); $taillemorceau=intval($taillepass/3); $pass1=substr($motpasse,0,$taillemorceau); $pass2=substr($motpasse,$taillemorceau,$taillemorceau); $pass3=substr($motpasse,($taillemorceau*2)); $passfin=hash($algo,"$pass1$alt1$pass2$alt2$pass3$alt3"); $taillepassf=strlen($passfin); $taillemorceauf=intval($taillepassf/3); $passf1=substr($passfin,0,$taillemorceauf); $passf2=substr($passfin,$taillemorceauf,$taillemorceauf); $passf3=substr($passfin,($taillemorceauf*2)); $passfou="$passf1$alt1$passf2$alt2$passf3$alt3"; // le mot de passe coupé, salé, hashé et re-salé est : return $passfou; }

`Génération de mot de passe aléatoire et/ou de sel`


voir l'article sur le salage en informatique sur Wikipedia.
Cette fonction génère donc une chaîne aléatoire, par exemple pour le sel aléatoire, qui devra être stocké, éventuellement pour chaque utilisateur.

Cela permet de se protéger (dans une certaine mesure) des attaques par rainbow table.
// génère une chaîne alpha-numérique aléatoire de longueur $taille function genere_chaine_aleatoire($taille) { $code_aleatoire=""; $chaine="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; srand((double)microtime()*1000000); for($i=0; $i<$taille; $i++) { $code_aleatoire.=$chaine[rand()%strlen($chaine)]; // ou $code_aleatoire .= substr($chaine,rand()%(strlen($chaine)),1); // ou $code_aleatoire .= $chaine[ rand(0, ($nb_chars-1)) ]; } // ou $code_aleatoire = str_shuffle('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'); return $code_aleatoire; }
si l'on veut casser et mélanger le sel et le mot de passe avant/après cryptage selon les chiffres compris dans le sel, il est possible, à sa génération, de rajouter une chaîne "0 à 9" au sel si celui-ci ne contient pas de chiffre, puis de mélanger le sel par la fonction str_shuffle().

`Choix d'un algorithme de hashage`


Ce bout de code cherche dans le tableau renvoyé par la fonction "hash_algos" les meilleurs algorithmes de hashage.

hash_algos() renvoie les algorithmes supportés sur le système.
Une fois trouvé, l'algorithme à utiliser pourra être stocké soit dans le fichier connect.php, soit dans la base de données, dans une table de méta-variables.

Les algorithmes à chercher sont triés par ordre "de préférence" du plus sûr (sha512, whrilpool...) au moins sûr (crc32).
 // chercher dans hash_algos si sha512, sha256, sha1... sont utilisables. $algos_prefs=array("sha512", "whirlpool", "sha384", "ripemd320", "sha256", "snefru256", "ripemd256", "snefru", "gost", "sha224", "ripemd160", "ripemd128", "fnv164", "joaat", "crc32b", "adler32", "fnv132", "crc32"); $algo=null; $i=0; $nbalgos=sizeof($algos_prefs); while (($i<$nbalgos)&&($algo==null)){ if (in_array($algos_prefs[$i],hash_algos())){ $info.="".$algos_prefs[$i]." est supporté
"; $algo=$algos_prefs[$i]; }else{ $info.="".$algos_prefs[$i]." non supporté
"; $i++; } } if ($algo==null){ $info.="Aucun algorithme supporté parmi ceux cherchés
"; $debug.="Aucun algorithme supporté parmi ceux cherchés"; }



Transformer une durée en secondes en sa description textuelle
Vader[FR] — 2018-07-01T10:23:43Z
// transforme une durée en secondes en sa description textuelle function sec2txt($durees){ $tabpuis=array("seconde","minute","heure","jour"); // + 30j/mois, 12 mois/an... ? $tabfrac=[60,60,24]; $traite=$durees; $puiss=0; $duree=""; while ($traite>=$tabfrac[$puiss]){ $reste=$traite%$tabfrac[$puiss]; $fraction=($traite-$reste)/$tabfrac[$puiss]; if ($reste>0){ $duree=($duree!="")?" $duree":$duree; $duree=($reste>1)?"$reste ".$tabpuis[$puiss]."s".$duree:"$reste ".$tabpuis[$puiss].$duree; } $puiss++; $traite=$fraction; } $duree=($duree!="")?" $duree":$duree; $duree=($traite>1)?"$traite ".$tabpuis[$puiss]."s".$duree:"$traite ".$tabpuis[$puiss].$duree; return $duree; }


Transformer un nombre (entier naturel) en sa description textuelle
Vader[FR] — 2018-07-01T10:20:45Z
// transforme un nombre en sa description textuelle
function num2txt($num){ $res=($num<0)?"moins":""; $tabchiffres=array("","un","deux","trois","quatre","cinq","six","sept","huit","neuf"); // commence à zéro ! $tabdix=array("","onze","douze","treize","quatorze","quinze","seize"); // idem $tabdizaines=array("","dix","vingt","trente","quarante","cinquante","soixante");	// idem $trnum=number_format($num); // pas de partie décimale, une , entre chaque millier $tabnum=explode(",",$trnum); $puiss=count($tabnum); // 1 = entre 0 et 999, 2 = entre 1000 et 999 999 milliers, 3 = entre 1 000 000 et 999 999 999 milions, 4 =... $tabpuis=array("","","mille","million","milliard"); // centaine/dizaine de milliards, centaine/dizaine de million, centaine/dizaine de millier, centaine/dizaine/unité foreach ($tabnum as $milnum){ $taillenum=strlen($milnum); $res.=($res!="")?" ":""; $verrounite=false; if ($taillenum==3) { // si 3 chiffres, traiter centaines // si 0 = rien, sinon x cent(s) if ($milnum[0]==1){ $res.="cent"; } if ($milnum[0]>1){ $res.=$tabchiffres[$milnum[0]]." cent"; $res.=(($milnum[1]>0)||($milnum[2]>0)||($puiss>=2))?"s":""; } } if ($taillenum>=2) { // si 2 chiffres, traiter dizaines $pos=($taillenum==3)?1:0; $res.=($res!="")?" ":""; //$res.=($pos!=0)?" ":""; $next=$pos+1; // si 1 if ($milnum[$pos]==1){ if (($milnum[$next]>=1)&&($milnum[$next]<=6)){ // onze à seize $res.=$tabdix[$milnum[$next]]; $verrounite=true; }else{ // 0 +	si 7 à 9 = dix- $res.=$tabdizaines[1]; $res.=($milnum[$next]>=7)?"-":""; } } // si 2 à 6 if (($milnum[$pos]>1)&&($milnum[$pos]<7)){ $res.=$tabdizaines[$milnum[$pos]]; $res.=($milnum[$next]>0)?"-":""; } // si 7, 8 et 9 qui utilisent aussi le chiffre des unités if ($milnum[$pos]==7){ $res.="soixante"; if ($milnum[$next]==0){ $res.="-dix"; } if ($milnum[$next]==1){ $res.=" et onze"; } if (($milnum[$next]>=2)&&($milnum[$next]<=6)){ $res.="-".$tabdix[$milnum[$next]]; } if ($milnum[$next]>=7){ $res.="-dix-".$tabchiffres[$milnum[$next]]; } $verrounite=true; } if ($milnum[$pos]==8){ //$verrounite=true; $res.="quatre-vingt"; if ($milnum[$next]>1){ $res.="-"; } } if ($milnum[$pos]==9){ $res.="quatre-vingt"; if ($milnum[$next]==0){ $res.="-dix"; } if (($milnum[$next]>=1)&&($milnum[$next]<=6)){ $res.="-".$tabdix[$milnum[$next]]; } if ($milnum[$next]>=7){ $res.="-dix-".$tabchiffres[$milnum[$next]]; } $verrounite=true; } } if ($taillenum>=1) { // si 1 chiffres $pos=$taillenum-1; // dernier chiffre 2-1 = 1 ? 3-1=2 if ($pos==0){ // 1 seul chiffre, donc si >1 ou 1 et puiss = 1, afficher le chiffre $res.=(($milnum>1)||(($milnum==1)&&($puiss==1)))?$tabchiffres[$milnum]:""; }else{ if ((!$verrounite)&&($milnum[$pos]!=0)){ // si chiffre dizaine != 7, 8 ou 9 $pre=$pos-1; if ($milnum[$pre]==0){ $res.=$tabchiffres[$milnum[$pos]]; } // si dizaine if ($milnum[$pre]==1){ // déjà un tiret $res.=$tabchiffres[$milnum[$pos]]; } // si vingt à 60 ou 80, et 1, mettre x et 1 if (((($milnum[$pre]>=2)&&($milnum[$pre]<=6))||($milnum[$pre]==8))&&($milnum[$pos]==1)){ $res.="et-".$tabchiffres[$milnum[$pos]]; } // si vingt à 60 ou 80 et pas 1 if (((($milnum[$pre]>=2)&&($milnum[$pre]<=6))||($milnum[$pre]==8))&&($milnum[$pos]!=1)){ $res.=$tabchiffres[$milnum[$pos]]; } } } } // si total>1, mettre le tabpuiss[puiss] if (($milnum>=1)&&($tabpuis[$puiss]!="")){ $res.=($res!="")?" ":""; $res.=$tabpuis[$puiss]; // mille est invariable // mais million, non $res.=(($puiss==3)&&($milnum>1))?"s":""; } $puiss--; } if ($num==0){ $res="zéro"; } return $res;
}


Exemples de fonctions PHP
Vader[FR] — 2016-07-27T08:09:54Z
Retour des erreurs

Lorsque les erreurs et autres messages à caractère informatif sont gérés dans les différents blocs, et empilés dans une variable qui sera au final affichée dans un bloc dédié (lequel peut être dépliant grâce au CSS).

Si l'on souhaite un style différent selon le niveau d'erreur atteint, les différents blocs peuvent faire appel à cette fonction, qui use d'opérateurs ternaires.
Il est aussi possible d'utiliser une variable globale pour le niveau d'erreur actuel, ce qui simplifie les appels à la fonction.
3 niveaux d'erreur sont gérés :
 info : tout va bien, on affiche un (ou plus) message(s) juste pour information
 debug : attention, risque d'erreur, tout n'est pas optimal
 error : erreur critique
function raise_debuglvl($lvl,$actuel){ $debuglvl=$actuel; $debuglvl=(($lvl=="info")&&($actuel=="info"))?"info":$debuglvl; $debuglvl=(($lvl=="debug")&&($actuel!="error"))?"debug":$debuglvl; $debuglvl=($lvl=="error")?"error":$debuglvl; return $debuglvl;
}
La déclaration du bloc d'affichage :
// bloc d'information - l'image sert au déploiement mais reste affichée dans le bloc déplié if ($debug!=""){ switch ($debuglvl) { case "info" : $debugimg="notif-info.gif"; break; // ou action-s-valide case "debug" : $debugimg="notif-warning.gif"; break; case "error" : $debugimg="notif-error.gif"; break; default: $debugimg="notif-warning.gif"; break; } echo "  $debug 
"; }
La page appelante déclare les variables $debug et $info :
 $debug contiendra les messages à afficher dans le bloc dédié
 $info contiendra les messages à afficher dans la page.
Les pages appelées (via include ou require empileront dans ces variables les messages qu'elles souhaitent soulever.

$debug.="message"; ou $info.="message";, cette dernière variable pouvant être affichée dans la page puis vidée.
exemple d'utilisation

dans un script gérant le login d'un utilisateur, on récupère (en étape 2) login/mot de passe.

Selon ce qui est fourni, on retourne en étape 1 en affichant un message d'erreur.
if ($etape==2){ if ((isset($_POST["user"]))&&($_POST["user"]!="")){ $user=$_POST["user"]; // vérifier pas d'espace (entre autre) if (!preg_match("/^[a-z][a-z0-9]+$/",$user)){ $debug.="nom utilisateur non conforme
"; } }else{ $debug.="nom utilisateur manquant
"; } if ((isset($_POST["motpass"]))&&($_POST["motpass"]!="")){ $motpass=$_POST["motpass"]; // vérifier pas d'espace (entre autre) if (!preg_match("/^[a-zA-Z0-9]+$/",$user)){ $debug.="mot de passe non conforme
"; } }else{ $debug.="mot de passe manquant
"; } if ($debug!=""){ $etape=1; $info=$debug; raise_debuglvl("debug",$debuglvl); }
}
if ($etape==2){
// comparaison BDD
}
if ($etape==1){ echo " Bloc navigation 
  $info "; // formulaire }
son style CSS

pour un bloc dépliable CSS situé en haut à gauche de la page :
#debug { position:absolute; top:0; left:0; width:32px; height:32px; z-index:42; line-height:0; font-size:0;
}
#debug img { height:auto; width:auto; max-height:32px; max-width:32px; visibility:visible;
}
#debug:hover { height:auto; width:auto; min-height:100px; min-width:200px; line-height:normal; font-size:1em; overflow-y:auto;
}
#debug:hover img { height:auto; width:auto;
}
#debug:hover img#deploi_debug { height:0; width:0; visibility:hidden;
}
/* =========================================== Messages de débogages =========================================== */
#debug.error{ background-color:#FF0000;
}
#debug.error:hover { background-color:#FF8C00;
} #debug.debug { background-color:#FF8C00; }
#debug.info { background-color:#ADD8E6;
}
#debug.debug:hover, #debug.info:hover { background-color:#ADD8E6;
}
.debug { color:#FF8C00; /*#FFB30A;*/ /*#FFA501;*/
}
.info { color:#40820D; }
.error { color:#FF0000; font-weight:bold;
}
redirection en https

Pas vraiment une fonction, mais un petit bout de code à mettre dans la section ....

Si la page est accédée en http non sécurisé, on redirige vers le mode sécurisé https, via une balise meta.
 // 'HTTPS' est défini à une valeur non-vide si le script a été appelé via le protocole HTTPS. if ((!isset($_SERVER['HTTPS']))||($_SERVER['HTTPS']=="")){ $url="https://".$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI']; echo ""; }



V) Requêtes SQL
Vader[FR] — 2012-11-07T17:46:33Z
La base citée en exemple, à savoir une gestion de bibliothèque, est un exemple "bateau" récurrent dans l'apprentissage du php/sql.

La gestion de bases plus complexes sera évoquée ultérieurement.
 Lecture 
Une requête est généralement constituée des 4 éléments suivants.
 la liste des champs à sélectionner : SELECT champ1, champ2...
 la liste des tables dans lesquelles récupérer ces champs : FROM table1, table2...
 une clause de filtrage : WHERE condition
 une clause de tri et/ou de groupage : ORDER BY/GROUP BY/HAVING
clause SELECT
On y liste les champs à sélectionner dans la base.

Les champs accessibles sont ceux des tables listées dans la clause FROM.

Si des champs de tables différentes ont le même nom, on mettra le nom de leur table suivi du nom du champ, séparés par un point : .

Par exemple select livre.nom,adherent.nom from livre, adherent
Cette requête n'a aucune utilité et va combiner tous les noms d'adhérents de la bibliothèque avec tous les noms de livres. 

Le nombre de lignes de résultat sera donc égal au nombre de lignes de la table adhérent multiplié par le nombre de lignes de la table livre.
Il existe des champs spéciaux, qui correspondent à des fonctions, dont :
 count(nom_champ) qui compte le nombre d'occurrence du champ nom_champ.
 max(nom_champ) qui retourne la valeur maximale prise par le champ nom_champ
 min(nom_champ) qui renvoie la valeur minimale
 avg(champ) qui renvoie la moyenne
 sum(champ) pour additionner
 ...
 distinct(nom_champ) qui sélectionne les valeurs différentes. Par exemple, un count(distinct(nom_champ)) comptera le nombre d'occurrences différentes de nom_champ, donc sans compter les doublons.
 *  est un champ spécial signifiant que l'on prend tous les champs de toutes les tables listées dans la clause FROM.
Dans le cas de champs spéciaux, il sera préférable d'utiliser des alias afin de faciliter la récupération des données, via le mot clé as.

Par exemple 

select count(identifiant) as nblivre from livre
clause FROM
On y liste les tables sur lesquelles s'effectuent la sélection, séparées par des virgules.
Bien que la connexion initiale se fasse sur une base unique, on peut faire une sélection sur plusieurs bases en précisant le nom de la base avant celui de la table, les deux étant séparés par un ".".

Il est là aussi possible d'utiliser des alias par le mot clé as

select champ1 from table1 as t1
En cas de sélection sur plusieurs tables, il est préférable d'opérer une jonction sur leurs points communs.

Le cas échéant, le système de gestion va tester la combinaison de chaque ligne de chaque table avec toutes les autres lignes de toutes les tables listées.

Cela multiplie inutilement les tests par la suite.
Il y a plusieurs types de jonctions, mais la plus courante est la jonction interne.
Par exemple, si la table des emprunts fait référence à un utilisateur et un livre, alors on va opérer une jonction sur l'identifiant utilisateur (utilisateur + emprunt) et sur l'identifiant livre (livre + emprunt).
select livre.titre,nom,date_emprunt from livre inner join emprunt on (emprunt.livre=livre.id) inner join adherent on (emprunt.adherent=adherent.id) 
A noter, une sous-requête peut servir de table. Cela consommera plus de ressources, mais parfois c'est le seul moyen.
Pour reprendre l'exemple de la bibliothèque, on pourrait compter le nombre de fois par personne où les livres ont été rendus en retard, puis prendre ceux dont le nombre de fois .... est supérieur ou égal à 3.
On fera alors quelque chose comme
 SELECT nom_personne from (SELECT count(*) as nombre_retard,nom_personne from emprunts inner join personnes on (emprunts.id_personne=personnes.id_personnes) where (date_rendu-date_pret)>=X group by id_personne) where nombre_retard>=3
Cela est également faisable avec une clause HAVING, ce qui allégerait la requête.
clause WHERE
La clause WHERE permet d'effectuer un filtre sur les lignes créées par les clauses SELECT ... FROM ..
Ce filtre est exécuté après le calcul de ces lignes. C'est pourquoi il est préférable de passer par une jonction dans la clause FROM lorsque cela est possible pour effectuer une correspondance entre deux (ou plus) tables.
Ce filtre est constitué d'une ou plusieurs conditions
 séparées par les mots-clés :
 "and" (et) si toutes les conditions doivent être remplies
 "or" (ou) si une seule des conditions suffit
 segmentées par des parenthèses "(" et ")" si besoin.
Une condition peut être :
 comparaison de deux champs avec signes "=", ">", ">=", "<", "<=" et "<>" (différence) ainsi que le mot-clé LIKE, pour comparaison de texte
 présence ou nom de la valeur d'un champ dans une sous-requête grâce au mot clé "in" ou "not in".
Par exemple, les personnes qui n'ont pas emprunté de livres sont celles qui ne sont pas présentes dans la table des emprunts.
SELECT nom_personne FROM personnes WHERE id_personne NOT IN (select distinct(id_personne) from emprunts);
Pour le texte, la comparaison avec le mot-clé LIKE s'effectue généralement sur une partie du contenu : WHERE champ LIKE '%valeur%' filtrera les lignes dont le champ texte "champ" contient (entre autre) le texte "valeur".
ORDER BY/GROUP BY/HAVING
 ORDER BY est une clause de tri.
On peut trier selon un ou deux champs, dans l'ordre ascendant (ASC) ou descendant (DESC)

Par exemple, tri sur une date, du plus ancien au plus récent donc de la plus petite date à la plus grande = ASC
select ... order by champ1 ASC
 GROUP BY est une clause de regroupement selon une égalité d'un champ.
Par exemple, pour avoir le nombre d'emprunts de chaque personne :

select count(*) as nbemprunts, id_personne from emprunts GROUP BY id_personne
 HAVING permet de filtrer sur les fonctions d'agrégat (et non de "simples" champs contrairement à la clause WHERE).
Par exemple, pour récupérer les personnes ayant plus de 50 emprunts.

select nom, count(emprunts.date_emprunt) as nbemprunts from personne inner join emprunts on (personne.id_personne=emprunts.id_personne) group by emprunts.id_personne having count(emprunts.date_emprunt)>=50
LIMIT
Cette clause permet de limiter le nombre de résultats renvoyés.

Cela peut être utile pour un système de pagination.
select ..... LIMIT debut,nombre

où début correspond à la première réponse récupérée (le tableau des réponses commence à zéro) et nombre... le nombre de réponses à prendre.
Par exemple, pour récupérer les 10 plus gros emprunteurs (non pas sur leur masse pondérale mais sur leur nombre d'emprunts) :

SELECT nbemprunts,nom_personne from (select max(count(*)) as nbemprunts, id_personne from emprunts group by id_personne) t1 inner join personne on (t1.id_personne=personne.id_personne) order by nbemprunts DESC LIMIT 0,10
Modification de la base de données
Mise à jour
La clause principale de la requête n'est plus SELECT mais UPDATE.
Les clauses secondaires (de filtre et choix de table) sont toujours valables.
On met à jour un champ d'une ou plusieurs lignes d'une table, en fonction de la valeur d'autres champs de ces mêmes lignes (ou pas).
Comme toujours, on commence par mettre la requête SQL dans une variable chaîne de caractères.

$reku="update operation_type set nom=\"$nom\" where id=$id" ;
puis on l'exécute, tout simplement

$resu=mysql_query($reku) ;
la syntaxe de la requête est de type UPDATE table SET CHAMP=nouvelle_valeur WHERE condition
Suppression
La clause principale de la requête n'est plus SELECT mais DELETE.
Les clauses secondaires (de filtre et choix de table) sont toujours valables.
On efface des lignes d'une table en fonction de la valeur de champs ce ces mêmes lignes.
Comme toujours, on commence par mettre la requête SQL dans une variable chaîne de caractères.

$rekd1="delete from operation_type where parent=$id" ;
puis on l'exécute, tout simplement

$resd1=mysql_query($rekd1) ;
la syntaxe de la requête est de type DELETE FROM table WHERE condition


IV) Interactions PHP/base SQL - principes
Vader[FR] — 2012-06-29T08:08:00Z
D'abord, il faut se connecter à la base.
mysql_connect('serveur_bdd','utilisateur_bdd','mot_de_passe_bdd','MYSQL'); // or die ?
mysql_select_db("nom_base");
Ces quelques lignes de code pourront être mises seulement dans un fichier php que l'on va ensuite inclure dans toutes les pages qui en auront besoin.

include "connect.php";
Note : le système d'inclusion en PHP (include, require, include_once...) sera évoqué dans un autre article.
Puis on construit la requête

exemple :

$rek_sel="select * from spip_articles where id_rubrique=$id_rubrique_diapo and statut='publie' order by 'date' DESC limit $debut,$par_page "; // order by date DESC 
Ici, il faut connaître suffisamment le langage SQL pour créer la requête. 

Cela sera détaillé dans l'article suivant, il faut simplement retenir pour l'instant le fait que l'on met une requête texte en langage SQL dans une variable PHP.
On l'exécute
$res_sel=mysql_query($rek_sel);
et on récupère le résultat
Si le résultat ne peut comporter qu'une seule ligne maximum.
On envoie le résultat brut renvoyé par la précédente commande dans un tableau (d'une seule ligne, de fait), lequel est associatif (chaque colonne est nommée selon les champs choisis dans la clause SELECT de la requête plus haut).

Puis on récupère la valeur du ou des champs ciblés.
$rek_compt="select count(*) as total from spip_articles where id_rubrique=$id_rubrique_diapo and statut='publie'";
$res_compt=mysql_query($rek_compt); $row_total=mysql_fetch_array($res_compt,MYSQL_ASSOC);
$total=$row_total["total"];
On prendra soin de tester si la valeur retournée est nulle ou chaîne vide, quand cela risque de se produire (ici, on a fait un comptage des lignes, donc forcément non vide, entre 0 et n).
Si le résultat comporte ou risque de comporter plusieurs lignes :
On envoie le résultat brut renvoyé par la commande précédente dans un tableau, lequel est de type associatif (chaque colonne est nommée selon les champs choisis dans la clause SELECT de la requête plus haut).

Puis on traite ce tableau ligne par ligne par une boucle WHILE (tant que le tableau de résultat renvoie une ligne, traiter la ligne).
while ($row_sel=mysql_fetch_array($res_sel,MYSQL_ASSOC)){ $id=$row_sel["id_article"]; $titre=htmlentities($row_sel["titre"]); $texte=htmlentities($row_sel["texte"]); ... ...
}
Ici, htmlentities(texte) est une fonction PHP qui permet de transformer les caractères spéciaux - qui risquent d'être interprétés en html - par leur code html équivalent.
Enfin, on ferme la connexion à la base.
mysql_close();
Même si le serveur gère les connexions inactives, c'est plus propre.
A noter, le SQL est un langage complet, les requêtes peuvent donc devenir très complexes.

Cela n'étant pas l'objet de cet article, seules les bases seront évoquées ici.

Un article sur le SQL "avancé" pourra être écrit plus tard.


III) Requête HTML et traitement PHP
Vader[FR] — 2012-03-31T15:10:33Z
Pour qu'un script php puisse générer une page différente en fonction des besoins de l'utilisateur, il faut lui fournir des paramètres et leurs valeurs.
Il existe pour cela 2 méthodes :
 la méthode GET, qui envoie les paramètres dans l'url. Cela a 2 inconvénients : la taille (limite de 256 caractères pour l'url) et la sécurité (affichage en clair des informations transmises)
 la méthode POST, qui envoie les paramètres d'une manière transparente.
Pour la première requête, il n'y a pas d'autre moyen, mais par la suite on pourra utiliser des variables de session (en cookie ou non).

Cela sera détaillé dans un autre article.
Méthode GET
Envoi par méthode GET
Cette méthode est plutôt réservée aux liens, mais peut servir aux formulaires, si les données à transmettre ne sont pas trop grandes.
Cela consiste à envoyer les paramètres et leurs valeurs dans l'url, selon la norme suivante :
 on signale l'envoi de paramètres par un ? après l'adresse du script.
 les paramètres/valeurs sont séparés par des &
 les espaces sont remplacés par des +
 les paramètres sont séparés de leur valeur par =
Dans un lien, cela donne par exemple :

http://graindimage.org/charger_diapo.php?id=0&delai=0
Ici, les données contenues dans la réponse sont ensuite utilisées par un script JavaScript pour le diaporama de la page de garde.
On peut par ailleurs voir les requêtes et leur réponse dans l'onglet réseau de Firebug des outils de développement web :


Firebug - requêtes

Cela peut permettre d'avoir des informations complémentaires en cas de besoin.
Dans un formulaire, la requête sera créée lors du clic sur le bouton/image/lien de validation.

On procède alors comme ceci :
 déclaration du formulaire - quel script récupère les informations, et comment on les envoie. L'adresse du script sera de préférence relative, depuis celle de la page en cours.
une fois le formulaire déclaré, il faut y mettre des champs :

 un champ chaîne de caractères. Ont peut préciser entre autres les attributs size (taille de la zone de saisie) et maxlength (taille maximale du texte que l'on peut saisir).

ce qui donne 

 un champ chaîne de caractères cachés, par exemple pour un mot de passe. Celui-ci étant affiché en clair en mode GET, il est préférable de ne l'utiliser qu'en POST

exemple 

 un champ caché. l'utilisateur ne saisira aucune information, celle-ci pouvant être inscrite en dur dans le formulaire, ou récupérée par une variable de session ou une saisie précédente.
 pour une zone de texte. on peut entre autres préciser cols et rows pour le nombre de colonnes (nombre de caractères dans une ligne) et de lignes.

exemple :

Il existe aussi d'autres types de champ, notamment pour l'envoi de fichiers. Le traitement de ceux-ci étant très particulier, il ne sera pas abordé ici.
Il va de soi que les noms des champs devront être différents.
Pour valider le formulaire, il y a 2 champs spéciaux possibles :
 un bouton

 une image
il existe aussi un champ spécial pour remise à zéro du formulaire. Le sujet de cet article étant le PHP et non l'HTML, il ne sera pas abordé ici.
 et on n'oublie pas de fermer le formulaire.
Méthode POST
Envoi par méthode POST
Cette méthode est plutôt réservée aux formulaires, mais peut servir aux liens, moyennant un petit bricolage qu'il faut tout de même éviter.
On procède pratiquement pareil que pour le GET :
 déclaration du formulaire - ici, on indique non plus la méthode GET mais POST
les champs sont les mêmes que ceux décrits précédemment.
ici, si l'on souhaite afficher un lien au lieu d'un bouton, l'astuce est de passer par un "bouton image" sans image source. 

C'est alors le texte alternatif qui sera affiché. Le problème est que sous IE, la petite croix rouge de "image absente" sera quand même affichée.

Cela peut servir pour, par exemple, un tri par clic sur l'entête de la colonne d'un tableau, l'ordre de tri, le début et les filtres passant en champs cachés.
 et on n'oublie pas de fermer le formulaire.
Les attributs HTML étant assez variés pour les différentes balises décrites dans cet article, seuls les plus courants ont été décrits.

Le sujet de cet article est le PHP, et non l'HTML.
Traitement des paramètres
Récupération et traitement des paramètres en PHP
Que ce soit GET ou POST, les instructions de récupération des paramètres seront mises de préférence au début du script.
Le code PHP est toujours entre deux balises  et ?>.

Chaque instruction PHP doit se finir par un point-virgule ;

Il est préférable d'indenter le code pour qu'il soit plus lisible. 

Des éditeurs comme gedit (sous Linux) ou Notepad++ (sous Windows) sont capables de reconnaître la syntaxe et de colorier le texte en conséquence. Cela permet de mieux suivre le code, et notamment repérer les " ;" manquants.

Les commentaires sont indiqués par // commentaire sur une ligne ou /* commentaires sur plusieurs lignes */

if (isset($_GET["id"])){  Il est plus propre de tester auparavant si le paramètre existe, en clair, s'il est défini (is set)

 $idd=$_GET["id"]; Si oui, on le récupère par la commande $_GET["nom_paramètre"] ;

}else{ Il est préférable aussi de prévoir une valeur "par défaut", au cas où. De même on aurait pu prévoir une vérification de la valeur du paramètre. De fait, il est plus simple de mettre cela plus loin dans le script.

 $idd=0;  la valeur par défaut

} 


Pour des variables en POST, le $_GET devient $_POST :
if (isset($_POST["id"])){ $idd=$_POST["id"]; }else{ $idd=0; }
On peut même imbriquer les deux méthodes, en essayant par exemple GET puis POST :
if (isset($_GET["id"])){ $idd=$_GET["id"]; }else{ if (isset($_POST["id"])){ $idd=$_POST["id"]; }else{ $idd=0; } }

Pour le traitement des valeurs récupérées et les fonctions/structures de PHP, voir les articles suivants...


II) Fonctionnement de PHP & MySQL
Vader[FR] — 2012-03-30T13:09:51Z
Combiner des scripts PHP avec une base de données, comme MySQL, permet de lire, voire même de modifier la base de manière transparente, par page web.
Un script, en fonction d'une requête utilisateur (recherche multi-critères...ou liens générés par lecture de la base) ira chercher les données pour générer la page contenant les informations demandées, et voire même modifiera les informations contenues dans la base en conséquence.
Cela permet par exemple de faire une page web d'annuaire en intranet avec outil de recherche par nom/prénom/service/bureau, ou de gérer une bibliothèque et ses emprunts.
..... ou de créer un site en mettant le contenu en ligne aisément par interface web, sans avoir besoin de connaissances en informatique, et de proposer aux visiteurs de participer à la vie du site en postant des commentaires ou en réagissant dans un forum.
Il existe des applications bien plus poussées de PHP & MySQL, permettant par exemple de faire de la gestion de parc informatique/helpdesk/inventaire/déploiement d'application/découverte réseau/cartographie... (il s'agit de ceci et cela).
Schéma de synthèse


Légende :

1) Requête client vers serveur, au format HTML. Le fonctionnement de ces requêtes sera détaillé dans un autre article.

2) Le script PHP, en fonction des besoin, génère une requête SQL (langage de la base de données)...

3) ... et récupère le résultat calculé par le système de gestion de la base de données

4) Après avoir généré le contenu de la page en fonction des données récupérées dans la base, le serveur envoie la page html au client.

5) Éventuellement, un script JavaScript inclut dans la page html, et exécuté par le navigateur client, envoie une requête vers le serveur

Le navigateur affiche toujours la page.

6) La page serveur ciblée par cette requête particulière effectue un traitement et envoie le résultat au navigateur, qui va alors modifier la page affichée dans le navigateur en temps réel.

On peut de cette manière recharger une partie précise de la page, ce qui est plus léger pour le réseau que le rechargement de la page entière.

Cette manœuvre est totalement transparente pour l'utilisateur, qui peut continuer la lecture de la page tout au long des phases 5 et 6.

C'est par exemple le cas pour le diaporama de la page de garde Grain d'Image


I) Présentations de PHP & MySQL
Vader[FR] — 2012-03-29T20:09:48Z


PHP est un langage interprété, qui va être exécuté par le serveur afin de générer du contenu à envoyer au navigateur client (page web html, script javascript, réponse XML, image...).
Il est donc indispensable de connaître d'abord le langage que l'on souhaite générer avant de s'intéresser au PHP.
Ce genre de programme (script) permet de générer dynamiquement une page web, en allant chercher le contenu ailleurs (saisie précédente utilisateur, lecture de fichier, ou plus couramment...base de donnée).
Le PHP est situé dans un ou plusieurs fichiers .php sur le serveur. Ces fichiers étant "par défaut" interprétés par le serveur, leur contenu n'est donc pas visible par un navigateur.
Par exemple, le système de gestion de contenu SPIP, qui a généré cette page, est basé sur un ensemble de scripts php allant chercher les données à afficher dans une base de données.
PHP est donc de fait très utilisé sur le web 2.0 puis 3.0, remplaçant les pages html statiques qui sont fastidieuses à maintenir et faire évoluer.


MySQL est une Base De Données, une structure permettant d'organiser, de hiérarchiser et de lier des données.
Le plus souvent ces données sont sous forme de texte, lequel peut être une date, un nombre, une chaîne de caractères ou un texte plus long....
Les images et le contenu plus "lourd" sera lui stocké sous forme de fichiers mais référencé sous formes de liens dans la base.
Une base est faîte de plusieurs tables.
Une table possède des colonnes (attributs ou champs) et des lignes (valeurs desdits attributs).
Chaque ligne, afin d'être unique, doit avoir un identifiant, via une ou plusieurs colonnes. Cela se nomme la clé primaire (Primary key).
L'organisation de ces données permet d'effectuer des requêtes afin d'obtenir des lignes correspondant aux valeurs des champs des tables demandées.
Ces deux logiciels sont inclus dans EasyphP.