Requete Sql Avec Pdo Et Mysqli

Pourquoi mélanger le PHP et le SQL ?

Vous avez appris SQL ? Vous avez appris PHP ?
Il est maintenant temps d'apprendre le mélange de PHP + SQL pour insérer, modifier, supprimer et consulter des données existantes.
Bref, en 1 mot, ce que tous les sites du monde (ou presque) font à longueur de journée !

Dans un site web, il est utile de pouvoir manipuler des données.

Quelques exemples rapides :

Insérer des données :
côté FRONT : Lorsqu'un internaute s'inscrit sur votre site web,
côté BACK : Lorsque vous ajoutez un nouveau produit dans votre boutique.

Modifier des données :
côté FRONT : Lorsqu'un internaute modifie son profil sur votre site web,
côté BACK : Lorsque vous modifiez le prix d'un produit de votre boutique.

Supprimer des données :
côté FRONT : Lorsqu'un internaute supprime son compte de votre site web,
côté BACK : Lorsque vous supprimez un produit de votre boutique.

Consulter des données :
côté FRONT : Lorsqu'un internaute souhaite se connecter à votre site web,
côté BACK : Lorsque vous affichez les produits de votre boutique.

Comment faire pour échanger des informations entre la base de données et la page web ?

Pour commencer, il vous faut une base de données.
Nous pouvons créer une base de données à l'aide de la console Mysql ou du gestionnaire PhpMyAdmin.
Création de la Base de données : entreprise
Avec la console Mysql :

	CREATE DATABASE entreprise;	

Si vous êtes en mode console, nous rajouterons une ligne de code pour dire au SGBD que nous souhaitons travailler sur notre base de données entreprise :

	USE entreprise;	

Avec le gestionnaire PhpMyAdmin :




Une fois la base de données "entreprise" créée et utilisée, nous aurons besoin d'une table pour contenir des enregistrements :
Création de la table : employes

	CREATE TABLE IF NOT EXISTS employes (
	  id_employes int(3) NOT NULL AUTO_INCREMENT,
	  prenom varchar(20) DEFAULT NULL,
	  nom varchar(20) DEFAULT NULL,
	  sexe enum('m','f') NOT NULL,
	  service varchar(30) DEFAULT NULL,
	  date_embauche date DEFAULT NULL,
	  salaire float DEFAULT NULL,
	  PRIMARY KEY (id_employes)
	) ENGINE=InnoDB  DEFAULT CHARSET=latin1 ;
	

Insertion et enregistrement des informations :
Dans tous les cas, voici les enregistrements à insérer dans la base de données entreprise afin d'avoir du contenu sur lequel travailler :

	INSERT INTO employes (id_employes, prenom, nom, sexe, service, date_embauche, salaire) VALUES
	(350, 'Jean-pierre', 'Laborde', 'm', 'direction', '1999-12-09', 5000),
	(388, 'Clement', 'Gallet', 'm', 'commercial', '2000-01-15', 2300),
	(415, 'Thomas', 'Winter', 'm', 'commercial', '2000-05-03', 3550),
	(417, 'Chloe', 'Dubar', 'f', 'production', '2001-09-05', 1900),
	(491, 'Elodie', 'Fellier', 'f', 'secretariat', '2002-02-22', 1600),
	(509, 'Fabrice', 'Grand', 'm', 'comptabilite', '2003-02-20', 1900),
	(547, 'Melanie', 'Collier', 'f', 'commercial', '2004-09-08', 3100),
	(592, 'Laura', 'Blanchet', 'f', 'direction', '2005-06-09', 4500),
	(627, 'Guillaume', 'Miller', 'm', 'commercial', '2006-07-02', 1900),
	(655, 'Celine', 'Perrin', 'f', 'commercial', '2006-09-10', 2700),
	(699, 'Julien', 'Cottet', 'm', 'secretariat', '2007-01-18', 1390),
	(701, 'Mathieu', 'Vignal', 'm', 'informatique', '2008-12-03', 2000),
	(739, 'Thierry', 'Desprez', 'm', 'secretariat', '2009-11-17', 1500),
	(780, 'Amandine', 'Thoyer', 'f', 'communication', '2010-01-23', 1500),
	(802, 'Damien', 'Durand', 'm', 'informatique', '2010-07-05', 2250),
	(854, 'Daniel', 'Chevel', 'm', 'informatique', '2011-09-28', 1700),
	(876, 'Nathalie', 'Martin', 'f', 'juridique', '2012-01-12', 3200),
	(900, 'Benoit', 'Lagarde', 'm', 'production', '2013-01-03', 2550),
	(933, 'Emilie', 'Sennard', 'f', 'commercial', '2014-09-11', 1800),
	(990, 'Stephanie', 'Lafaye', 'f', 'assistant', '2015-06-02', 1775);
	

MYSQLI

Mysqli est une classe prédéfinie de PHP permettant la connexion et l'exécution de requête sur le SGBD MySQL en PHP.

MYSQLI : Se connecter à la base de données MYSQL

Création du fichier : mysqli.php
Ensuite, il vous faut aussi un fichier où vous pourrez écrire le code (script).
Pour cela, rien de plus facile puisque'il s'agit de créer un simple fichier nommé "mysqli.php" sur le serveur local (repertoire /www/).

Avant de pouvoir formuler des requêtes, il faut absolument relier la base de données à votre fichier (script).
Pour cela, nous devons le préciser en haut de fichier :

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	

Quelques Explications :
Mysqli est une classe prédéfinie de PHP permettant de se connecter à une base de données et de formuler des requêtes SQL.
Les arguments/paramètres entrants vont directement dans le constructeur de la classe (méthode exécutée par défaut).
Les arguments/paramètres correspondent à :

• nom du serveur = localhost
• pseudo = root
• mot de passe = (sous wamp, le mot de passe est vide - sous mamp, il sera nécessaire d'écrire "root")
• nom de la base de données = entreprise

Techniquement, nous pouvons dire que $mysqli est une variable représentant 1 objet issu de la classe Mysqli.

Humainement, nous pouvons dire que $mysqli est une variable permettant d'être connecté à la base et de formuler des requêtes.

Pour mieux connaitre la classe Mysqli, vous pouvez consulter la documentation officielle : Classe Mysqli
Vous pouvez aussi demander l'affichage des propriétés avec l'instruction print_r et aussi la fonction prédéfinie get_class_methods() :

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	echo '
'; print_r($mysqli); echo '
';
	echo '
'; print_r(get_class_methods($mysqli)); echo '
';
	

Nous aurons l'occasion d'utiliser plusieurs des propriétés et méthodes présentes dans cette liste.

MYSQLI : Ecrire une première requête SQL

Pour formuler une première reqûete SQL dans une page web, nous aurons besoin de passer par l'objet $mysqli et d'utiliser la méthode query() :

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	echo '
'; print_r($mysqli); echo '
';
	echo '
'; print_r(get_class_methods($mysqli)); echo '
';
	//-----------------------------------------------------------------
	$mysqli->query("mauvaise requete volontaire .........");
	echo $mysqli->error . '
';
	

Debug
Comme vous pouvez le voir, la propriété nommée error de l'objet Mysqli nous permet d'avoir accès aux éventuelles erreurs SQL.
Pour cet exemple, vous aurez donc une erreur puisque c'était volontaire de montrer comment se débugger dans le cas d'une mauvaise requête SQL.

---

MYSQLI : Insérer, Modifier et surpprimer des données

MYSQLI : Insérer des données

Voici le code permettant d'insérer des données avec la classe Mysqli :

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	// Insertion :
	$result = $mysqli->query("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('prenom', 'nom', 'm', 'informatique', '2015-07-30', 5000),");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête INSERT
';
	//-----------------------------------------------------------------
	

Profitez en pour vous attribuer un bon salaire, c'est vous qui decidez :p.
Query permet de formuler une requête SQL dans le code PHP.
Nous avons prévu une variable $result juste avant pour obtenir un retour :

• Dans le cas d'une erreur de requete SQL, $result contiendra : (boolean) FALSE
• Dans le cas d'une bonne requete SQL, $result contiendra : (boolean) TRUE

affected_rows permet d'observer le nombre d'enregistrements affectés par une requête.

Après l'INSERT, allez voir le contenu de votre table (en passant par la console Mysql ou le gestionnaire PhpMyAdmin), vous verrez que l'employé à bien été ajouté !

---

MYSQLI : Modifier des données

Voici le code permettant de modifier des données avec la classe Mysqli :

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	// Insertion (INSERT) :
	$result = $mysqli->query("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('prenom', 'nom', 'm', 'informatique', '2015-07-30', 5000)");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête INSERT
';
	//-----------------------------------------------------------------
	// Modification (UPDATE) :
	$result = $mysqli->query("UPDATE employes SET salaire = 2500 WHERE id_employes = 802");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête UPDATE
';
	//-----------------------------------------------------------------
	

Nous modifions le salaire de l'employé 802 (Damien Durand), initialement à 2250, il passera à 2500.
Query permet de formuler une requête SQL dans le code PHP.

Nous avons prévu une variable $result juste avant pour obtenir un retour :

• Dans le cas d'une erreur de requete SQL, $result contiendra : (boolean) FALSE
• Dans le cas d'une bonne requete SQL, $result contiendra : (boolean) TRUE

affected_rows permet d'observer le nombre d'enregistrements affectés par une requête.

Avant et après l'UPDATE, allez voir le contenu de votre table (en passant par la console Mysql ou le gestionnaire PhpMyAdmin), vous verrez que l'employé à bien été modifié !

---

MYSQLI : Supprimer des données

Voici le code permettant de supprimer des données avec la classe Mysqli :

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	// Insertion (INSERT) :
	$result = $mysqli->query("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('prenom', 'nom', 'm', 'informatique', '2015-07-30', 5000)");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête INSERT
';
	//-----------------------------------------------------------------
	// Modification (UPDATE) :
	$result = $mysqli->query("UPDATE employes SET salaire = 2500 WHERE id_employes = 802");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête UPDATE
';
	//-----------------------------------------------------------------
	// Suppression (DELETE) :
	$result = $mysqli->query("DELETE FROM employes WHERE id_employes = 388");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête DELETE
';
	//-----------------------------------------------------------------
	

Nous supprimons l'employé 388 (Clement Gallet).
Query permet de formuler une requête SQL dans le code PHP.

Nous avons prévu une variable $result juste avant pour obtenir un retour :

• Dans le cas d'une erreur de requete SQL, $result contiendra : (boolean) false
• Dans le cas d'une bonne requete SQL, $result contiendra : (boolean) TRUE

affected_rows permet d'observer le nombre d'enregistrements affectés par une requête.

Avant et après la reqûete DELETE, allez voir le contenu de votre table (en passant par la console Mysql ou le gestionnaire PhpMyAdmin), vous verrez que l'employé à bien été supprimé !

---

MYSQLI : Sauvegarder des informations

MYSQLI : Sauvegarder les informations d'un formulaire dans une base de données (SQL/PHP)

Maintenant que l'on sait échanger des informations entre la base de données et la page web, nous pourrions travailler avec des formulaires !
La création d'un formulaire permettant d'ajouter des employés serait judicieux afin qu'une personne non familière des langages informatiques puisse mettre à jour la base de données facilement.

Création d'un nouveau fichier : formulaire-mysqli.php

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	if($_POST)
	{
		$result = $mysqli->query("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('$_POST[prenom]', '$_POST[nom]', '$_POST[sexe]', '$_POST[service]', '$_POST[date_embauche]', '$_POST[salaire]')");
		echo '
l\'employé a bien été ajouté
';
	}
	?>
	
	

		Prenom

		


		Nom

		


		Sexe

		Homme  -
		Femme 	


		Service

		


		Date d'embauche (Format: AAAA-MM-JJ)

		


		Salaire

		


		


	
	

Explications

Lorsque nous arrivons la première fois sur la page, le code PHP se trouvant dans le IF est ignoré puisque personne n'a validé le formulaire.
Lorsque l'internaute clique sur le bouton submit, cela recharge la page (le script), et la partie de code PHP dans le IF est exécutée pour enregistrer l'employé qu'on nous aura posté.

Bien entendu, ce formulaire peut être amélioré.
Dans l'idéal, il faudrait réaliser des contrôles (est-ce que tous les champs ont été correctement remplis, etc.), le sécuriser (se protéger d'éventuelles attaques), et augmenter l'expérience utilisateur (en proposant par exemple 1 calendrier pour selectionner une date d'embauche).

En l'état, ce formulaire est fonctionnel et c'est bien là l'essentiel pour l'apprentissage de notre cours.

---

MYSQLI : Selectionner et afficher des données

MYSQLI : Selectionner et afficher 1 enregistrement

Pour afficher dans la page web les données d'1 enregistrement à l'intérieur de la base, le code sera légérement différent.
Voici le code permettant d'effectuer un affichage de données avec la classe Mysqli :

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	// Insertion (INSERT) :
	$result = $mysqli->query("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('prenom', 'nom', 'm', 'informatique', '2015-07-30', 5000)");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête INSERT
';
	//-----------------------------------------------------------------
	// Modification (UPDATE) :
	$result = $mysqli->query("UPDATE employes SET salaire = 2500 WHERE id_employes = 802");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête UPDATE
';
	//-----------------------------------------------------------------
	// Suppression (DELETE) :
	$result = $mysqli->query("DELETE FROM employes WHERE id_employes = 388");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête DELETE
';
	//-----------------------------------------------------------------
	// Affichage (SELECT) :
	$result = $mysqli->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch_assoc(); 
	echo "
"; print_r($employe); echo "
";
	echo "Bonjour je suis $employe[prenom] $employe[nom] du service $employe[service]
";
	//-----------------------------------------------------------------
	

Query
Nous selectionnons un employé en particulier (Julien, à vous de vérifier s'il est bien présent dans votre table, sinon il faudra changer le prénom ou selectionner directement par un id existant).
Nous obtenons l'enregistrement demandé dans la variable $result prévue pour récupérer le retour de la requête SQL.

$result
Nous avons prévu une variable $result juste avant la requête pour obtenir un retour.
Par défaut, le retour de la requête SQL crée un nouvel objet, issu de la classe MYSQLI_RESULT

• Dans le cas d'une erreur de requete SQL, $result contiendra : (boolean) false
• Dans le cas d'une bonne requete SQL, $result contiendra : (object) MYSQLI_RESULT Si la requête est bonne, vous obtiendrez un autre objet issu d'une autre classe (MYSQLI_RESULT) !

fetch_assoc
Le résultat (ressource) sous forme d'objet MYSQLI_RESULT n'est pas exploitable en l'état.
Pour accèder aux données que nous avons selectionnées précédemment, nous avons besoin d'utiliser la méthode (fonction) fetch_assoc() de la classe Mysqli_Result ($result->fetch_assoc()). La méthode fetch_assoc() permet de rendre un résultat exploitable sous forme de tableau ARRAY associatif.

$employe
$employe est donc un tableau ARRAY associatif (associatif = avec des clés nominatives).
Nous pouvons donc afficher notre tableau ARRAY par l'intermédiaire d'un print_r ou d'un echo

affected_rows permet toujours d'observer le nombre d'enregistrements affectés par une requête.


Avec cette requête de SELECTion, nous avons pu afficher 1 enregistrement de la table employes.

---

MYSQLI : Selectionner et afficher plusieurs enregistrements

Pour afficher dans la page web les données de PLUSIEURS enregistrements à l'intérieur de la base, le code sera encore différent.
Voici le code permettant d'effectuer un affichage de données avec la classe Mysqli :

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	// Insertion (INSERT) :
	$result = $mysqli->query("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('prenom', 'nom', 'm', 'informatique', '2015-07-30', 5000)");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête INSERT
';
	//-----------------------------------------------------------------
	// Modification (UPDATE) :
	$result = $mysqli->query("UPDATE employes SET salaire = 2500 WHERE id_employes = 802");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête UPDATE
';
	//-----------------------------------------------------------------
	// Suppression (DELETE) :
	$result = $mysqli->query("DELETE FROM employes WHERE id_employes = 388");
	echo $mysqli->affected_rows . ' enregistrement(s) affecté(s) par la requête DELETE
';
	//-----------------------------------------------------------------
	// Affichage (SELECT) :
	$result = $mysqli->query("SELECT * FROM employes");
	while($employe = $result->fetch_assoc())
	{
		echo "
"; print_r($employe); echo "
";
		echo "Bonjour je suis $employe[prenom] $employe[nom] du service $employe[service]";
	}
	echo $result->num_rows . ' enregistrement(s) récupéré(s) par la requête SELECT'
;
	//-----------------------------------------------------------------
	

Query
Nous selectionnons tous les employés.
Nous obtenons les enregistrements demandés dans la variable $result prévue pour récupérer le retour de la requête SQL.

$result
Nous avons prévu une variable $result juste avant la requête pour obtenir un retour.
Par défaut, le retour de la requête SQL crée un nouvel objet, issu de la classe MYSQLI_RESULT

• Dans le cas d'une erreur de requete SQL, $result contiendra : (boolean) false
• Dans le cas d'une bonne requete SQL, $result contiendra : (object) MYSQLI_RESULT Si la requête est bonne, vous obtiendrez un autre objet issu d'une autre classe (MYSQLI_RESULT) !

While
while est une boucle permettant d'effectuer une répétition.
Pourquoi effectuer une répétition ?
Parce que nous avons plusieurs lignes d'enregistrements à récupérer. Il est donc nécessaire de répéter le traitement fetch_assoc() afin de rendre le résultat exploitable sous forme d'array.
La boucle While permet d'afficher chaque ligne de la table (tant que l'on possède des enregistrements, on les affiche).




fetch_assoc
Le résultat (ressource) sous forme d'objet MYSQLI_RESULT n'est pas exploitable en l'état.
Pour accèder aux données que nous avons selectionnées précédemment, nous avons besoin d'utiliser la méthode (fonction) fetch_assoc() de la classe MYSQLI_RESULT ($result->fetch_assoc()). La méthode fetch_assoc() permet de rendre un résultat exploitable sous forme de tableau ARRAY associatif.
Avec la présence de la boucle while, nous obtiendrons un nouveau tableau ARRAY dans la variable $employe, à chaque tour de boucle.
/!\ Il y aura pas un tableau ARRAY avec tous les enregistrements à l'intérieur mais bien un nouveau tableau ARRAY par enregistrement, un array par employé !

$employe
$employe est donc un tableau ARRAY associatif (associatif = avec des clés nominatives).
Nous pouvons donc afficher notre tableau ARRAY par l'intermédiaire d'un print_r ou d'un echo

num_rows permet d'observer le nombre d'enregistrements récupérés et affichés par une requête.


Avec cette requête de SELECTion, nous avons pu afficher tous les enregistrements de la table employes.

MYSQLI : Une table SQL sous forme de table HTML

Voici le code qui permettrait de reproduire la table sql (de la base de données) dans une table html (dans la page web).

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	
	$résultat = $mysqli->query("SELECT * FROM employes");

	echo '<table border="5"> <tr>';
	while($colonne = $résultat->fetch_field())
	{		   
		echo '<th>' . $colonne->name . '</th>';
	}
	echo "</tr>";

	while ($ligne = $résultat->fetch_assoc())
	{
		echo '<tr>';
		foreach ($ligne as $indice => $information)
		{
			echo '<td>' . $information . '</td>';
		}
		echo '</tr>';
	}
	echo '</table>';
	?>

Toutes les explications

Nous allons tâcher d'expliquer chaque ligne pour une compréhension optimale.

$mysqli = new Mysqli("localhost", "root", "", "entreprise");

Cette ligne représente la connexion à notre base de données avec les informations suivantes : nom du serveur, pseudo, mot de passe, nom de la base de données.
Humainement, $mysqli représente la variable permettant de communiquer et de gérer des échanges avec la base de données.
Techniquement, $mysqli est un objet issu de la classe Mysqli.

$résultat = $mysqli->query("SELECT * FROM employes");

Cette ligne permet de formuler une requête SQL afin de selectionner tous les employés de la table via la méthode query() de l'objet $mysqli.
Nous recupèrons le résultat de la requete dans la variable $résultat.

echo '<table border="5"> <tr>';

Nous créons une table html avec une première ligne (<tr>)

while($colonne = $résultat->fetch_field())

Pour consulter le nom des champs/colonnes de la table SQL, nous aurons besoin d'utiliser la méthode fetch_field() qui permet de récolter des informations sur les champs/colonnes.

La boucle While est présente pour répéter cette action puisqu'il y a plusieurs champs/colonnes à afficher

$colonne est 1 objet (de la StdClass) car la méthode fetch_field() que nous utilisons est prévue de récolter des informations sur les champs/colonnes d'une table SQL et de faire un retour sous forme d'objet.

En 1 mot : fetch_field() est une méthode de l'objet Mysqli_Result qui nous permet de récupérer des informations sur les champs sous forme d'objet.

Nous faisons tourner une première boucle while pour parcourir tous les champs et obtenir des informations via la méthode fetch_field() afin d’écrire les en-têtes de notre tableau HTML sur la première ligne (balise tr).

echo '<th>' . $colonne->name . '</th>';

Nous inscrivons des <th> (en html) pour commencer l'affichage des entêtes de la table.
A l'intérieur des balises html <th>, nous avons besoin d'inscrire les noms des champs.
Nous passons donc par la variable $colonne (remplie précédement avec fetch_field()) et nous demandons le name du champ.
Nous aurions pu demander d'autres informations tel que le type $colonne->type.
Pour voir les informations auxquelles nous avons accès, il est possible d'effectuer un print_r($colonne); ou de consulter la documentation officielle à ce sujet !

A chaque tour de boucle, le nom du champ sera affiché.

echo "</tr>";

Nous terminons l'affichage de la 1ère ligne en fermant la balise </tr>.

while ($ligne = $résultat->fetch_assoc())

fetch_assoc permet de traiter le résultat et de le rendre exploitable sous forme de tableau ARRAY (nous utilisons la méthode fetch_assoc de l'objet mysqli_result).
$ligne représente un tableau array associatif contenant le résultat.
while permet de répéter cette action tant qu'il y a des résultats et de passer à la ligne d'enregistrement suivante pour faire avancer les traitements.

Nous mettons en place une boucle while pour parcourir chaque enregistrement (soit 1 ligne par enregistrement) de la table SQL.

echo "<tr>";

Nous préparons l'affichage d'une prochaine ligne en ouvrant la balise <tr>.

foreach($ligne as $indice => $information)

La boucle foreach va nous permettre de parcourir notre tableau array représenté par la variable $ligne et d'afficher chacune des informations contenues à l'intérieur.
Chaque employé possède 7 informations : id_employes, prenom, nom, sexe, service, date_embauche, salaire.
La boucle while est présente pour traiter chaque employé (et avancer sur l'employé suivant), tandis que, la boucle foreach est présente pour traiter et afficher chaque information pour chaque employé.

Lorsque nous faisons 1 tour dans la boucle while, cela entraine 7 tours dans la boucle foreach.
S'il y a 20 employés, la boucle while fera 20 tours et la boucle foreach 140 tours (20 employés x 7 informations).
Voici ce que ça donne :
o While : Employé n°1

• Foreach : information n°1
• Foreach : information n°2
• Foreach : information n°3
• Foreach : information n°4
• Foreach : information n°5
• Foreach : information n°6
• Foreach : information n°7

o While : Employé n°2

• Foreach : information n°1
• Foreach : information n°2
• Foreach : information n°3
• Foreach : information n°4
• Foreach : information n°5
• Foreach : information n°6
• Foreach : information n°7

o While : Employé n°3

• Foreach : information n°1
• Foreach : information n°2
• Foreach : information n°3
• Foreach : information n°4
• Foreach : information n°5
• Foreach : information n°6
• Foreach : information n°7

etc.

echo '<td>' . $information . '</td>';

Cette ligne (présente à l'intérieur de la boucle foreach) permet d'afficher chaque information d'un employé via $information dans une nouvelle balise <td>.

echo "</tr>";

Nous terminons l'affichage de la ligne en fermant la balise </tr>.

echo "</table>";

Nous terminons l'affichage de notre table en fermant la balise </table>.





Dans les grandes lignes :

- Nous accèdons aux entêtes des colonnes/champs avec la méthode fetch_field() (apres une requete SELECT) - cela retourne un objet (de type OBJECT).
- Nous accèdons aux informations sur les enregistrements avec fetch_assoc (ou fetch_row, fetch_array, fetch_object, fetch_all, apres une requete SELECT) - cela retourne un tableau ou un objet (de type array ou object)
- Nous accèdons aux nombre d'enregistrements avec num_rows (apres une requete SELECT) et affected_rows (apres une requete INSERT, UPDATE, DELETE) - cela retourne le nombre (de type INT).


Vous pouvez garder ce code en référence pour vos besoins. Il suffira juste d'adapter le nom de la table sur laquelle vous effectuez une requête SQL.
C'est une première approche, ne prenez pas peur, nous reviendrons dessus jusqu'à ce que chaque mot, chaque détail, soit compris !

MYSQLI : Résumé technique et explicatif

Pour résumé:

Mysqli et Mysqli_Result
$mysqli représente un objet [1] issu de la classe prédéfinie Mysqli

Lorsqu'on exécute une requete de SELECTion via la méthode QUERY() sur l'objet Mysqli :
En cas de succès : On obtient un autre objet[2] issue de la classe Mysqli_Result. Cet objet à donc des méthodes et des propriétés différentes !
En cas d'echec : On obtient un boolean False

Lorsqu'on exécute une requete INSERT/UPDATE/DELETE via la méthode QUERY() sur l'objet Mysqli, c'est plus simple :
En cas de succès : On obtient un boolean TRUE.
En cas d'echec : On obtient un boolean FALSE

Pour comprendre techniquement dans la précision, n'hésitez pas à lancer var_dump($mysqli) ou var_dump($result);

While : boucle ou pas boucle ?
S'il n'y a qu'une seule ligne d'enregistrement à récupérer dans le résultat, nous ne ferons pas de boucle while.
S'il y a plusieurs lignes d'enregistrements à récupérer dans le résultat, il faut prévoir une boucle while.

Techniquement, la boucle while permet de faire avancer le curseur sur la ligne suivante dans la table.

affected_rows et num_rows
Dans le cas d'une action (INSERT, UPDATE, DELETE), nous utiliserons affected_rows pour voir le nombre d'enregistrements affectés (touchés) par une requête.
Dans le cas d'une question/réponse (SELECT), nous utiliserons num_rows pour voir le nombre d'enregistrements récupérés (et affichés) par une requête.

Pas d'affichage ou une erreur SQL ?
Dans le cas d'une erreur ou d'un affichage incohérent, n'hésitez pas à vérifier votre code PHP mais aussi votre code SQL (puisque maintenant nous mélangeons les 2 langages !).
Pour cela, vous pouvez utiliser (après une requête), le code suivant : $mysqli->error.

Fetch
La méthode fetch_assoc permet de traiter les résultat afin d'obtenir un tableau ARRAY.
Cette étape est indispensable si l'on souhaite produire un affichage par la suite.

D'autres méthodes de traitement existent.

fetch_assoc

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	$result = $mysqli->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch_assoc(); 
	echo "
"; print_r($employe); echo "
";
	echo $employe[prenom] . '
';
	?>

Nous pouvons dire que fetch_assoc a l'avantage de donner des clés associatives/nominatives (correspondant au nom des champs/colonnes dans la table SQL) au tableau ARRAY.


fetch_row

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	$result = $mysqli->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch_row(); 
	echo $employe[0] . '
';
	echo "
"; print_r($employe); echo "
";
	?>

Nous pouvons dire que fetch_row donne des clés numériques (correspondant a l'ordre des champs/colonnes dans la table SQL) au tableau ARRAY.


fetch_array

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	$result = $mysqli->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch_array(); 
	echo "
"; print_r($employe); echo "
";
	echo $employe['prenom'] . $employe[0] . '
';
	?>

Nous pouvons dire que fetch_array est une combinaison du fetch_assoc et du fetch_row, cela donne des clés numérique (correspondant a l'ordre des champs/colonnes dans la table SQL) et des clés associatives/nominatives (correspondant au nom des champs/colonnes dans la table SQL) au tableau ARRAY.


fetch_object

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	$result = $mysqli->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch_object(); 
	echo "
"; print_r($employe); echo "
";
	echo $employe->prenom . '
';
	?>

fetch_object ne produit pas un tableau mais un objet (de la StdClass, class standard en PHP). Les champs/colonnes de la tables SQL deviennent le nom des propriétés de l'objet. Pour accèder à l'une d'entre-elles, il sera nécessaire d'utiliser la syntaxe suivante : $employe->prenom.


fetch_all

	<?php
	$mysqli = new Mysqli("localhost", "root", "", "entreprise");
	//-----------------------------------------------------------------
	$result = $mysqli->query("SELECT * FROM employes");
	$employe = $result->fetch_all(); 
	echo "
"; print_r($employe); echo "
";
	echo $employe->prenom . '
';
	?>

Cette fois-ci nous avons modifié la requête SQL de départ pour selectionner tous les enregistrements (tous les employés).
Habituellement nous avons un nouveau tableau ARRAY représentant chaque ligne d'enregistrement.
Avec fetch_all cela sera exactement pareil sauf que nous aurons un tableau supplémentaire englobant tous les autres tableaux.

Pour résumé :
fetch_array retourne une ligne de résultats MySQL sous la forme d'un tableau dôté de clés nominatives et aussi numériques.
fetch_row retourne une ligne de résultats MySQL sous la forme d'un tableau dôté de clés numériques.
fetch_assoc retourne une ligne de résultats MySQL sous la forme d'un tableau dôté de clés nominatives. Cette solution est souvent préconisée.
fetch_object retourne une ligne de résultats MySQL sous la forme d'un objet avec comme attributs les champs de la table sur laquelle la requête a été effectuée.


La classe Mysqli :
mysqli — La classe mysqli
mysqli::$affected_rows — Retourne le nombre de lignes affectées par la dernière opération MySQL
mysqli::autocommit — Active ou désactive le mode auto-commit
mysqli::begin_transaction — Démarre une transaction
mysqli::change_user — Change l'utilisateur de la connexion spécifiée
mysqli::character_set_name — Retourne le jeu de caractères courant pour la connexion
mysqli::$client_info — Récupère les informations du client MySQL
mysqli::$client_version — Retourne la version du client MySQL sous la forme d'une chaîne de caractères
mysqli::close — Ferme une connexion
mysqli::commit — Valide la transaction courante
mysqli::$connect_errno — Retourne le code d'erreur de la connexion MySQL
mysqli::$connect_error — Retourne le message d'erreur de connexion MySQL
mysqli::__construct — Ouvre une connexion à un serveur MySQL
mysqli::debug — Effectue des actions de déboguage
mysqli::dump_debug_info — Écrit les informations de déboguage dans les logs
mysqli::$errno — Retourne le dernier code d'erreur produit
mysqli::$error_list — Retourne une liste d'erreurs depuis la dernière commande exécutée
mysqli::$error — Retourne une chaîne décrivant la dernière erreur
mysqli::$field_count — Retourne le nombre de colonnes pour la dernière requête
mysqli::get_charset — Retourne un objet représentant le jeu de caractères
mysqli::get_client_info — Récupère des informations sur le client MySQL
mysqli_get_client_stats — Retourne des statistiques sur le client, par processus
mysqli_get_client_version — Retourne la version du client MySQL sous forme d'un entier
mysqli::get_connection_stats — Retourne des statistiques sur la connexion
mysqli::$host_info — Retourne une chaîne contenant le type de connexion utilisée
mysqli::$protocol_version — Retourne la version du protocole MySQL utilisé
mysqli::$server_info — Retourne la version du serveur MySQL
mysqli::$server_version — Retourne un entier représentant la version du serveur MySQL
mysqli::get_warnings — Lit le résultat de SHOW WARNINGS
mysqli::$info — Retourne des informations à propos de la dernière requête exécutée
mysqli::init — Initialise MySQLi et retourne une ressource à utiliser avec mysqli_real_connect()
mysqli::$insert_id — Retourne l'identifiant automatiquement généré par la dernière requête
mysqli::kill — Demande au serveur de terminer un thread MySQL
mysqli::more_results — Vérifie s'il y a d'autres jeux de résultats MySQL disponibles
mysqli::multi_query — Exécute une requête MySQL multiple
mysqli::next_result — Prépare le prochain résultat d'une requête multiple
mysqli::options — Définit les options
mysqli::ping — Ping la connexion au serveur et reconnecte si elle n'existe plus
mysqli::poll — Vérifie l'état de la connexion
mysqli::prepare — Prépare une requête SQL pour l'exécution
mysqli::query — Exécute une requête sur la base de données
mysqli::real_connect — Ouvre une connexion à un serveur MySQL
mysqli::real_escape_string — Protège les caractères spéciaux d'une chaîne pour l'utiliser dans une requête SQL, en prenant en compte le jeu de caractères courant de la connexion
mysqli::real_query — Exécute une requête SQL
mysqli::reap_async_query — Lit un résultat pour une requête asynchrone
mysqli::refresh — Rafraîchit
mysqli::release_savepoint — Supprime le point de sauvegarde nommé du jeu des points de sauvegarde de la transaction courante
mysqli::rollback — Annule la transaction courante
mysqli::rpl_query_type — Retourne le type de requête RPL
mysqli::savepoint — Définit un point de sauvegarde nommé de la transaction
mysqli::select_db — Sélectionne une base de données par défaut pour les requêtes
mysqli::send_query — Envoie la requête et retourne
mysqli::set_charset — Définit le jeu de caractères par défaut du client
mysqli::set_local_infile_default — Rétablit le gestionnaire par défaut pour la commande LOAD LOCAL INFILE
mysqli::set_local_infile_handler — Définit une fonction de rappel pour la commande LOAD DATA LOCAL INFILE
mysqli::$sqlstate — Retourne l'erreur SQLSTATE de la dernière opération MySQL
mysqli::ssl_set — Utilisée pour établir une connexion sécurisée avec SSL
mysqli::stat — Obtient le statut courant du système
mysqli::stmt_init — Initialise une commande MySQL
mysqli::store_result — Transfère un jeu de résultats à partir de la dernière requête
mysqli::$thread_id — Retourne l'identifiant du thread pour la connexion courante
mysqli::thread_safe — Indique si le support des threads est activé ou pas
mysqli::use_result — Initialise la récupération d'un jeu de résultats
mysqli::$warning_count — Retourne le nombre d'avertissements générés par la dernière requête

La classe Mysqli_result :
mysqli_result — La classe mysqli_result
mysqli_result::$current_field — Récupère la position courante d'un champ dans un pointeur de résultat
mysqli_result::data_seek — Déplace le pointeur interne de résultat
mysqli_result::fetch_all — Lit toutes les lignes de résultats dans un tableau
mysqli_result::fetch_array — Retourne une ligne de résultat sous la forme d'un tableau associatif, d'un tableau indexé, ou les deux
mysqli_result::fetch_assoc — Récupère une ligne de résultat sous forme de tableau associatif
mysqli_result::fetch_field_direct — Récupère les métadonnées d'un champ unique
mysqli_result::fetch_field — Retourne le prochain champs dans le jeu de résultats
mysqli_result::fetch_fields — Retourne un tableau d'objets représentant les champs dans le résultat
mysqli_result::fetch_object — Retourne la ligne courante d'un jeu de résultat sous forme d'objet
mysqli_result::fetch_row — Récupère une ligne de résultat sous forme de tableau indexé
mysqli_result::$field_count — Récupère le nombre de champs dans un résultat
mysqli_result::field_seek — Déplace le pointeur de résultat sur le champ spécifié
mysqli_result::free — Libère la mémoire associée à un résultat
mysqli_result::$lengths — Retourne la longueur des colonnes de la ligne courante du jeu de résultats
mysqli_result::$num_rows — Retourne le nombre de lignes dans un résultat

Source : http://php.net/manual/fr/book.mysqli.php

PDO (Php Data Object)

Pdo (Php Data Object) est une classe prédéfinie de PHP (par extension) permettant la connexion et l'exécution de requête sur le SGBD MySQL en PHP.

Cet extension est plus populaire que Mysqli, notamment pour son style orienté objet et la possibilité de migrer d'un SGBD à un autre sans avoir à réécrire la totalité du code.

PDO : Se connecter à la base de données MYSQL

Création du fichier : pdo.php
Ensuite, il vous faut aussi un fichier où vous pourrez écrire le code (script).
Pour cela, rien de plus facile puisque'il s'agit de créer un simple fichier nommé "pdo.php" sur le serveur local (repertoire /www/).
Avant de pouvoir formuler des requêtes, il faut absolument relier la base de données à votre fichier (script).
Pour cela, nous devons le préciser en haut de fichier :

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	

Quelques Explications :
Pdo est une classe prédéfinie de PHP permettant de se connecter à une base de données et de formuler des requêtes SQL.
Les arguments/paramètres entrants vont directement dans le constructeur de la classe (méthode exécutée par défaut).
Les arguments/paramètres correspondent à :

• host = nom du serveur = localhost
• dbname = nom de la base de données = entreprise
• pseudo = root
• mot de passe = (sous wamp, le mot de passe est vide - sous mamp, il sera nécessaire d'écrire "root")
• Erreur mode activé pour faire apparaitre d'eventuelles erreurs de requête SQL

Techniquement, nous pouvons dire que $pdo est une variable représentant 1 objet issu de la classe Pdo.

Humainement, nous pouvons dire que $pdo est une variable permettant d'être connecté à la base et de formuler des requêtes.

Pour mieux connaitre la classe Pdo, vous pouvez consulter la documentation officielle : Classe Pdo
Vous pouvez aussi demander l'affichage des propriétés avec l'instruction print_r et aussi la fonction prédéfinie get_class_methods() :

	<?php
	$pdo = new Pdo("localhost", "root", "", "entreprise");
	echo '
'; print_r($pdo); echo '
';
	echo '
'; print_r(get_class_methods(pdo)); echo '
';
	

Nous aurons l'occasion d'utiliser plusieurs des propriétés et méthodes présentes dans cette liste.

---

PDO : Ecrire une première requête SQL

Pour formuler une première reqûete SQL dans une page web, nous aurons besoin de passer par l'objet $pdo et d'utiliser la méthode query() ou exec() par exemple :

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	echo '
'; print_r($pdo); echo '
';
	echo '
'; print_r(get_class_methods($pdo)); echo '
';
	

---

PDO : Insérer, Modifier et supprimer des données

PDO : Insérer des données

Voici le code permettant d'insérer des données avec la classe Pdo :

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	// Insertion :
	$result = $pdo->exec("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('prenom', 'nom', 'm', 'informatique', '2015-07-30', 5000),");
	echo $result . ' enregistrement(s) affecté(s) par la requête INSERT
';
	//-----------------------------------------------------------------
	

Profitez en pour vous attribuer un bon salaire, c'est vous qui decidez :p.
Exec (ou Query) permet de formuler une requête SQL dans le code PHP.
Nous avons prévu une variable $result juste avant pour obtenir un retour :

• Dans le cas d'une erreur de requete SQL, $result contiendra : (boolean) FALSE
• Dans le cas d'une bonne requete SQL, $result contiendra : (int) 1 ou N selon le nombre de résultat(s) touché(s) par la requête

$result contient le nombre de résultat(s) touché(s) par la requête grâce à l'utilisation de la méthode exec().
Nous aurions également pu utiliser la méthode query() pour cette requête mais nous n'aurions pas eu accès aux nombres de résultat(s) touchés par la requête.
Après l'INSERT, allez voir le contenu de votre table (en passant par la console Mysql ou le gestionnaire PhpMyAdmin), vous verrez que l'employé à bien été ajouté !

---

PDO : Modifier des données

Voici le code permettant de modifier des données avec la classe Pdo :

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	// Insertion (INSERT) :
	$result = $pdo->exec("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('prenom', 'nom', 'm', 'informatique', '2015-07-30', 5000),");
	echo $result . ' enregistrement(s) affecté(s) par la requête INSERT
';
	//-----------------------------------------------------------------
	// Modification (UPDATE) :
	$result = $pdo->exec("UPDATE employes SET salaire = 2500 WHERE id_employes = 802");
	echo $result . ' enregistrement(s) affecté(s) par la requête UPDATE
';
	//-----------------------------------------------------------------
	

Nous modifions le salaire de l'employé 802 (Damien Durand), initialement à 2250, il passera à 2500.
Exec (ou Query) permet de formuler une requête SQL dans le code PHP.

Nous avons prévu une variable $result juste avant pour obtenir un retour :

• Dans le cas d'une erreur de requete SQL, $result contiendra : (boolean) FALSE
• Dans le cas d'une bonne requete SQL, $result contiendra : (int) 1 ou N selon le nombre de résultat(s) touché(s) par la requête

$result contient le nombre de résultat(s) touché(s) par la requête grâce à l'utilisation de la méthode exec().
Nous aurions également pu utiliser la méthode query() pour cette requête mais nous n'aurions pas eu accès aux nombre de résultat(s) touché(s) par la requête.

Avant et après l'UPDATE, allez voir le contenu de votre table (en passant par la console Mysql ou le gestionnaire PhpMyAdmin), vous verrez que l'employé à bien été modifié !

---

PDO : Supprimer des données

Voici le code permettant de supprimer des données avec la classe Pdo :

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	// Insertion (INSERT) :
	$result = $pdo->exec("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('prenom', 'nom', 'm', 'informatique', '2015-07-30', 5000),");
	echo $result . ' enregistrement(s) affecté(s) par la requête INSERT
';
	//-----------------------------------------------------------------
	// Modification (UPDATE) :
	$result = $pdo->exec("UPDATE employes SET salaire = 2500 WHERE id_employes = 802");
	echo $result . ' enregistrement(s) affecté(s) par la requête UPDATE
';
	//-----------------------------------------------------------------
	// Suppression (DELETE) :
	$result = $pdo->exec("DELETE FROM employes WHERE id_employes = 388");
	echo $result . ' enregistrement(s) affecté(s) par la requête DELETE
';
	//-----------------------------------------------------------------
	

Nous supprimons l'employé 388 (Clement Gallet).
Query permet de formuler une requête SQL dans le code PHP.

Nous avons prévu une variable $result juste avant pour obtenir un retour :

• Dans le cas d'une erreur de requete SQL, $result contiendra : (boolean) FALSE
• Dans le cas d'une bonne requete SQL, $result contiendra : (int) 1 ou N selon le nombre de résultat(s) touché(s) par la requête

$result contient le nombre de résultat(s) touché(s) par la requête grâce à l'utilisation de la méthode exec().
Nous aurions également pu utiliser la méthode query() pour cette requête mais nous n'aurions pas eu accès aux nombre de résultat(s) touché(s) par la requête.

Avant et après la reqûete DELETE, allez voir le contenu de votre table (en passant par la console Mysql ou le gestionnaire PhpMyAdmin), vous verrez que l'employé à bien été supprimé !

---

PDO : Sauvegarder des informations

PDO : Sauvegarder les informations d'un formulaire dans une base de données (SQL/PHP)

Maintenant que l'on sait échanger des informations entre la base de données et la page web, nous pourrions travailler avec des formulaires !
La création d'un formulaire permettant d'ajouter des employés serait judicieux afin qu'une personne non familière des langages informatiques puisse mettre à jour la base de données facilement.

Création d'un nouveau fichier : formulaire-pdo.php

	<?php
	$pdo = new Pdo("localhost", "root", "", "entreprise");
	if($_POST)
	{
		$result = $pdo->exec("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('$_POST[prenom]', '$_POST[nom]', '$_POST[sexe]', '$_POST[service]', '$_POST[date_embauche]', '$_POST[salaire]')");
		echo '
l\'employé a bien été ajouté
';
	}
	?>
	
	

		Prenom

		


		Nom

		


		Sexe

		Homme  -
		Femme 	


		Service

		


		Date d'embauche (Format: AAAA-MM-JJ)

		


		Salaire

		


		


	
	

Explications

Lorsque nous arrivons la première fois sur la page, le code PHP se trouvant dans le IF est ignoré puisque personne n'a validé le formulaire.
Lorsque l'internaute clique sur le bouton submit, cela recharge la page (le script), et la partie de code PHP dans le IF est exécutée pour enregistrer l'employé qu'on nous aura posté.

Bien entendu, ce formulaire peut être amélioré.
Dans l'idéal, il faudrait réaliser des contrôles (est-ce que tous les champs ont été correctement remplis, etc.), le sécuriser (se protéger d'éventuelles attaques), et augmenter l'expérience utilisateur (en proposant par exemple 1 calendrier pour selectionner une date d'embauche).

En l'état, ce formulaire est fonctionnel et c'est bien là l'essentiel pour l'apprentissage de notre cours.

---

PDO : Selectionner et afficher des données

PDO : Selectionner et afficher 1 enregistrement

Pour afficher dans la page web les données d'1 enregistrement à l'intérieur de la base, le code sera légérement différent.
Voici le code permettant d'effectuer un affichage de données avec la classe Pdo :

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	// Insertion (INSERT) :
	$result = $pdo->exec("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('prenom', 'nom', 'm', 'informatique', '2015-07-30', 5000),");
	echo $result . ' enregistrement(s) affecté(s) par la requête INSERT
';
	//-----------------------------------------------------------------
	// Modification (UPDATE) :
	$result = $pdo->exec("UPDATE employes SET salaire = 2500 WHERE id_employes = 802");
	echo $result . ' enregistrement(s) affecté(s) par la requête UPDATE
';
	//-----------------------------------------------------------------
	// Suppression (DELETE) :
	$result = $pdo->exec("DELETE FROM employes WHERE id_employes = 388");
	echo $result . ' enregistrement(s) affecté(s) par la requête DELETE
';
	//-----------------------------------------------------------------
	// Affichage (SELECT) :
	$result = $pdo->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch(PDO::FETCH_ASSOC); 
	echo "
"; print_r($employe); echo "
";
	echo "Bonjour je suis $employe[prenom] $employe[nom] du service $employe[service]
";
	//-----------------------------------------------------------------
	

Query
Nous selectionnons un employé en particulier (Julien, à vous de vérifier s'il est bien présent dans votre table, sinon il faudra changer le prénom ou selectionner directement par un id existant).
Nous obtenons l'enregistrement demandé dans la variable $result prévue pour récupérer le retour de la requête SQL.

$result
Nous avons prévu une variable $result juste avant la requête pour obtenir un retour.
Par défaut, le retour de la requête SQL crée un nouvel objet, issu de la classe PDOSTATEMENT

• Dans le cas d'une erreur de requete SQL, $result contiendra : (boolean) false
• Dans le cas d'une bonne requete SQL, $result contiendra : (object) PDOSTATEMENT Si la requête est bonne, vous obtiendrez un autre objet issu d'une autre classe (PDOSTATEMENT) !

fetch(PDO::FETCH_ASSOC)
Le résultat (ressource) sous forme d'objet PDOSTATEMENT n'est pas exploitable en l'état.
Pour accèder aux données que nous avons selectionnées précédemment, nous avons besoin d'utiliser la méthode (fonction) fetch(PDO::FETCH_ASSOC) de la classe PDOSTATEMENT ($result->fetch(PDO::FETCH_ASSOC)). La méthode fetch(PDO::FETCH_ASSOC) permet de rendre un résultat exploitable sous forme de tableau ARRAY associatif.

$employe
$employe est donc un tableau ARRAY associatif (associatif = avec des clés nominatives).
Nous pouvons donc afficher notre tableau ARRAY par l'intermédiaire d'un print_r ou d'un echo


Avec cette requête de SELECTion, nous avons pu afficher 1 enregistrement de la table employes.

---

PDO : Selectionner et afficher plusieurs enregistrements

Pour afficher dans la page web les données de PLUSIEURS enregistrements à l'intérieur de la base, le code sera encore différent.
Voici le code permettant d'effectuer un affichage de données avec la classe Pdo :

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	// Insertion (INSERT) :
	$result = $pdo->exec("INSERT INTO employes (prenom, nom, sexe, service, date_embauche, salaire) VALUES ('prenom', 'nom', 'm', 'informatique', '2015-07-30', 5000),");
	echo $result . ' enregistrement(s) affecté(s) par la requête INSERT
';
	//-----------------------------------------------------------------
	// Modification (UPDATE) :
	$result = $pdo->exec("UPDATE employes SET salaire = 2500 WHERE id_employes = 802");
	echo $result . ' enregistrement(s) affecté(s) par la requête UPDATE
';
	//-----------------------------------------------------------------
	// Suppression (DELETE) :
	$result = $pdo->exec("DELETE FROM employes WHERE id_employes = 388");
	echo $result . ' enregistrement(s) affecté(s) par la requête DELETE
';
	//-----------------------------------------------------------------
	// Affichage (SELECT) :
	$result = $pdo->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch(PDO::FETCH_ASSOC); 
	echo "
"; print_r($employe); echo "
";
	echo "Bonjour je suis $employe[prenom] $employe[nom] du service $employe[service]
";
	//-----------------------------------------------------------------
	// Affichage (SELECT) :
	$result = $pdo->query("SELECT * FROM employes");
	while($employe = $result->fetch(PDO::FETCH_ASSOC))
	{
		echo "
"; print_r($employe); echo "
";
		echo "Bonjour je suis $employe[prenom] $employe[nom] du service $employe[service]";
	}
	echo $result->rowCount() . ' enregistrement(s) récupéré(s) par la requête SELECT'
;
	//-----------------------------------------------------------------
	

Query
Nous selectionnons tous les employés.
Nous obtenons les enregistrements demandés dans la variable $result prévue pour récupérer le retour de la requête SQL.

$result
Nous avons prévu une variable $result juste avant la requête pour obtenir un retour.
Par défaut, le retour de la requête SQL crée un nouvel objet, issu de la classe PDOSTATEMENT

• Dans le cas d'une erreur de requete SQL, $result contiendra : (boolean) false
• Dans le cas d'une bonne requete SQL, $result contiendra : (object) PDOSTATEMENT Si la requête est bonne, vous obtiendrez un autre objet issu d'une autre classe (PDOSTATEMENT) !

While
while est une boucle permettant d'effectuer une répétition.
Pourquoi effectuer une répétition ?
Parce que nous avons plusieurs lignes d'enregistrements à récupérer. Il est donc nécessaire de répéter le traitement fetch(PDO::FETCH_ASSOC) afin de rendre le résultat exploitable sous forme d'array.
La boucle While permet d'afficher chaque ligne de la table (tant que l'on possède des enregistrements, on les affiche).


votre requete sort plusieurs résultats ? : une boucle !
votre requete ne doit sortir qu'un seul et unique résultat ? : Pas de boucle !
votre requete ne sort qu'un seul résultat à l'instant T mais peut potentiellement en sortir plusieurs plus tard ? : une boucle !


fetch(PDO::FETCH_ASSOC)
Le résultat (ressource) sous forme d'objet PDOSTATEMENT n'est pas exploitable en l'état.
Pour accèder aux données que nous avons selectionnées précédemment, nous avons besoin d'utiliser la méthode (fonction) fetch(PDO::FETCH_ASSOC) de la classe PDOSTATEMENT (fetch(PDO::FETCH_ASSOC)). La méthode fetch(PDO::FETCH_ASSOC) permet de rendre un résultat exploitable sous forme de tableau ARRAY associatif.
Avec la présence de la boucle while, nous obtiendrons un nouveau tableau ARRAY dans la variable $employe, à chaque tour de boucle.
/!\ Il y aura pas un tableau ARRAY avec tous les enregistrements à l'intérieur mais bien un nouveau tableau ARRAY par enregistrement, un array par employé !

$employe
$employe est donc un tableau ARRAY associatif (associatif = avec des clés nominatives).
Nous pouvons donc afficher notre tableau ARRAY par l'intermédiaire d'un print_r ou d'un echo

rowCount() est une méthode de l'objet PDOSTATEMENT permettant d'observer le nombre d'enregistrements récupérés et affichés par une requête.


Avec cette requête de SELECTion, nous avons pu afficher tous les enregistrements de la table employes.

PDO : Une table SQL sous forme de table HTML

Voici le code qui permettrait de reproduire la table sql (de la base de données) dans une table html (dans la page web).

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	
	$résultat = $pdo->query("SELECT * FROM employes");

	echo "<table border=\"5\"> <tr>";
	for($i=0; $i<$résultat->columnCount(); $i++)
	{
		$colonne = $résultat->getColumnMeta($i);
		echo '<th>'.$colonne['name'].'</th>';
	}
	echo "</tr>";

	while ($ligne = $résultat->fetch(PDO::FETCH_ASSOC))
	{
		echo '<tr>';
		foreach ($ligne as $indice => $information)
		{
			echo '<td>' . $information . '</td>';
		}
		echo '</tr>';
	}
	echo '</table>';
	?>

Toutes les explications

Nous allons tâcher d'expliquer chaque ligne pour une compréhension optimale.

$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));

Cette ligne représente la connexion à notre base de données avec les informations suivantes : nom du serveur, pseudo, mot de passe, nom de la base de données.
Humainement, $pdo représente la variable permettant de communiquer et de gérer des échanges avec la base de données.
Techniquement, $pdo est un objet issu de la classe Pdo.

$résultat = $pdo->query("SELECT * FROM employes");

Cette ligne permet de formuler une requête SQL afin de selectionner tous les employés de la table via la méthode query() de l'objet $pdo.
Nous recupèrons le résultat de la requete dans la variable $résultat.

echo '<table border="5"> <tr>';

Nous créons une table html avec une première ligne (<tr>)

for($i=0; $i < $résultat->columnCount(); $i++)

Nous aurons besoin d'enclencher des tours de boucle, pour savoir combien de tours nous devons effectuer, la méthode columnCount() nous permettra de savoir combien il y a de champs/colonnes au total.
La boucle for est donc présente pour répéter l'action d'affichage et le traitement puisqu'il y a plusieurs champs/colonnes à afficher

$meta = $résultat->getColumnMeta($i);

Pour consulter le nom des champs/colonnes de la table SQL, nous utiliserons la méthode getColumnMeta() qui nous permettra de récolter des informations sur les champs/colonnes
$colonne est 1 array car la méthode getColumnMeta() que nous utilisons est prévue pour récolter des informations sur les champs/colonnes d'une table SQL et de faire un retour sous forme d'array.

En 1 mot : getColumnMeta() est une méthode de l'objet PDOSTATEMENT qui nous permet de récupérer des informations sur les champs sous forme d'array.

echo '<th>' . $colonne['name'] . '</th>';

Nous inscrivons des <th> (en html) pour commencer l'affichage des entêtes de la table.
A l'intérieur des balises html <th>, nous avons besoin d'inscrire les noms des champs.
Nous passons donc par la variable $colonne (remplie précédement avec getColumnMeta()) et nous demandons le name du champ.
Pour voir les autres informations auxquelles nous pouvons avoir accès, il est possible d'effectuer un print_r($colonne); ou de consulter la documentation officielle à ce sujet !

A chaque tour de boucle, le nom du champ sera affiché.

echo "</tr>";

Nous terminons l'affichage de la 1ère ligne en fermant la balise </tr>.

while ($ligne = $résultat->fetch(PDO::FETCH_ASSOC))

fetch_assoc permet de traiter le résultat et de le rendre exploitable sous forme de tableau ARRAY (nous utilisons la méthode fetch_assoc de l'objet mysqli_result).
$ligne représente un tableau array associatif contenant le résultat.
while permet de répéter cette action tant qu'il y a des résultats et de passer à la ligne d'enregistrement suivante pour faire avancer les traitements.

echo "<tr>";

Nous préparons l'affichage d'une prochaine ligne en ouvrant la balise <tr>.

foreach($ligne as $indice => $information)

La boucle foreach va nous permettre de parcourir notre tableau array représenté par la variable $ligne et d'afficher chacune des informations contenues à l'intérieur.
Chaque employé possède 7 informations : id_employes, prenom, nom, sexe, service, date_embauche, salaire.
La boucle while est présente pour traiter chaque employé (et avancer sur l'employé suivant), tandis que, la boucle foreach est présente pour traiter et afficher chaque information pour chaque employé.

Lorsque nous faisons 1 tour dans la boucle while, cela entraine 7 tours dans la boucle foreach.
S'il y a 20 employés, la boucle while fera 20 tours et la boucle foreach 140 tours (20 employés x 7 informations).

echo '<td>' . $information . '</td>';

Cette ligne (présente à l'intérieur de la boucle foreach) permet d'afficher chaque information d'un employé via $information dans une nouvelle balise <td>.

echo "</tr>";

Nous terminons l'affichage de la ligne en fermant la balise </tr>.

echo "</table>";

Nous terminons l'affichage de notre table en fermant la balise </table>.



Vous pouvez garder ce code en référence pour vos besoins. Il suffira juste d'adapter le nom de la table sur laquelle vous effectuez une requête SQL.
C'est une première approche, ne prenez pas peur, nous reviendrons dessus jusqu'à ce que chaque mot, chaque détail, soit compris !

PDO : Résumé technique et explicatif

Pour résumé:

PDO et PDOSTATEMENT
$pdo représente un objet [1] issu de la classe prédéfinie Pdo

Lorsqu'on exécute une requete de SELECTion via la méthode QUERY() sur l'objet Pdo :
En cas de succès : On obtient un autre objet[2] issu de la classe PDOSTATEMENT. Cet objet à donc des méthodes et des propriétés différentes !
En cas d'echec : On obtient un boolean False

Lorsqu'on exécute une requete INSERT/UPDATE/DELETE via la méthode QUERY() sur l'objet Pdo, c'est plus simple :
En cas de succès : On obtient un boolean TRUE.
En cas d'echec : On obtient un boolean FALSE

Pour comprendre techniquement dans la précision, n'hésitez pas à lancer var_dump($pdo) ou var_dump($result);

While : boucle ou pas boucle ?
S'il n'y a qu'une seule ligne d'enregistrement à récupérer dans le résultat, nous ne ferons pas de boucle while.
S'il y a plusieurs lignes d'enregistrements à récupérer dans le résultat, il faut prévoir une boucle while.

Techniquement, la boucle while permet de faire avancer le curseur sur la ligne suivante dans la table.

rowCount()
Dans le cas d'une requête de SELECTion, nous utiliserons rowCount() pour voir le nombre d'enregistrements récupérés (et affichés) par une requête.

Fetch
La méthode fetch(PDO::FETCH_ASSOC) permet de traiter les résultat afin d'obtenir un tableau ARRAY.
Cette étape est indispensable si l'on souhaite produire un affichage par la suite.

D'autres méthodes de traitement existent.

PDO::FETCH_ASSOC

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	$result = $pdo->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch(PDO::FETCH_ASSOC); 
	echo "
"; print_r($employe); echo "
";
	echo $employe[prenom] . '
';
	?>

Nous pouvons dire que PDO::FETCH_ASSOC a l'avantage de donner des clés associatives/nominatives (correspondant au nom des champs/colonnes dans la table SQL) au tableau ARRAY.


PDO::FETCH_ROW

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	$result = $pdo->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch(PDO::FETCH_ROW); 
	echo $employe[0] . '
';
	echo "
"; print_r($employe); echo "
";
	?>

Nous pouvons dire que PDO::FETCH_ROW donne des clés numériques (correspondant a l'ordre des champs/colonnes dans la table SQL) au tableau ARRAY.


PDO::FETCH_ARRAY

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	$result = $pdo->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch(PDO::FETCH_ARRAY);
	echo "
"; print_r($employe); echo "
";
	echo $employe['prenom'] . $employe[0] . '
';
	?>

Nous pouvons dire que PDO::FETCH_ARRAY est une combinaison du PDO::FETCH_ASSOC et du PDO::FETCH_ROW, cela donne des clés numériques (correspondant a l'ordre des champs/colonnes dans la table SQL) et des clés associatives/nominatives (correspondant au nom des champs/colonnes dans la table SQL) au tableau ARRAY.


PDO::FETCH_OBJECT

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	$result = $pdo->query("SELECT * FROM employes WHERE prenom='julien'");
	$employe = $result->fetch(PDO::FETCH_OBJECT);
	echo "
"; print_r($employe); echo "
";
	echo $employe->prenom . '
';
	?>

PDO::FETCH_OBJECT ne produit pas un tableau mais un objet (de la StdClass, class standard en PHP). Les champs/colonnes de la tables SQL deviennent le nom des propriétés de l'objet.
Pour accèder à l'une d'entre-elles, il sera nécessaire d'utiliser la syntaxe suivante : $employe->prenom.


PDO::FETCH_ALL

	<?php
	$pdo = new PDO('mysql:host=localhost;dbname=entreprise', 'root', '', array(PDO::ATTR_ERRMODE=>PDO::ERRMODE_EXCEPTION));
	//-----------------------------------------------------------------
	$result = $mysqli->query("SELECT * FROM employes");
	$employe = $result->fetch(PDO::FETCH_ALL);
	echo "
"; print_r($employe); echo "
";
	echo $employe->prenom . '
';
	?>

Cette fois-ci nous avons modifié la requête SQL de départ pour selectionner tous les enregistrements (tous les employés).
Habituellement nous avons un nouveau tableau ARRAY représentant chaque ligne d'enregistrement.
Avec PDO::FETCH_ALL cela sera exactement pareil sauf que nous aurons un tableau supplémentaire englobant tous les autres tableaux.


CHOIX DU CONNECTEUR DE BASE DE DONNEES
Nous pouvons utiliser librement la classe Mysqli ou la classe PDO pour échanger des données avec la base.