CLASSE MYSQL UTILISANT LES FONCTIONS PDO

<?php
/**
*	Classe de manipulation de base MySQL
*	
*	Dernière mise à jour : 17/09/2010
**/
class Db
{
	private $connection = false;				//Instance PDO
	
	private $ActiveTransaction = false;			//Flag indiquant si une transaction a été démarrée
	
	private $sql = '';							//Dernière requête SQL executée
	
	/**	Fonction Constructeur
	*	Desc 	:	Initialise la connexion
	*	Params 	:	(string)$Serveur = Adresse du serveur MySQL
	*				(string)$Utilisateur = Nom d'utilisateur de la base MySQL
	*				(string)$MotDePasse = Mot de passe MySQL
	*				(string)$BaseDeDonnees = Nom de la base de données
	*	Return	:	Void
	**/
	public function __construct($Serveur, $Utilisateur, $MotDePasse, $BaseDeDonnees)
	{
		try {
			//On instancie l'objet PDO et on se connecte à la base
			$this->connection = new PDO('mysql:host='.$Serveur.';dbname='.$BaseDeDonnees, $Utilisateur, $MotDePasse, array(PDO::ATTR_PERSISTENT => true));
		} catch (PDOException $e) {
			//En cas d'erreur, on affiche un message avec l'erreur retournée
			echo 'Connexion &eacute;chou&eacute;e : <b>'.$e->getMessage().'</b>';
		}
	}
	
	/** Fonction BeginTransaction
	*	Desc	:	Démarre une transaction MySQL
	*	Params	:	None
	*	Return	:	Void
	**/
	public function BeginTransaction()
	{
		//S'il n'existe pas de transaction active, on l'active
		if (!$this->ActiveTransaction)
			$this->ActiveTransaction = $this->connection->beginTransaction();
	}
	
	/** Fonction CommitTransaction
	*	Desc	:	Valide une transaction MySQL
	*	Params	:	None
	*	Return	:	(bool)true si la validation s'est bien passée, sinon false
	**/
	public function CommitTransaction()
	{
		try {
			//Si une transaction est active
			if ($this->ActiveTransaction)
			{
				//On la valide
				if ($this->connection->commit())
				{
					//Il n'y a plus de transaction active
					$this->ActiveTransaction = false;
					//La validation s'est bien passée donc on retourne true
					return true;
				}
				else
				{
					//Si la validation retourne false, on créé une erreur
					Throw new Exception('La transaction n\'a pas pu &ecirc;tre valid&eacute;e.<br />'.$this->GetError());
				}
			} else {
				//S'il n'y a pas de transaction active, on créé une erreur
				Throw new Exception('Aucune transaction active');
			}
		} catch (Exception $e) {
			//En cas d'erreur, on affiche un message avec l'erreur retournée
			echo 'Impossible de valider la transaction : <b>'.$e->getMessage().'</b>';
			return false;
		}
	}
	
	/** Fonction GetFrom
	*	Desc	: 	Retourne un tableau contenant les enregistrements selon les conditions spécifiées
	*	Params	: 	(string|array)$Table = Table SQL
	*				(string|array)$Fields = Champ(s) à retourner
	*				(string|array)$Where = Conditions WHERE
	*				(string|array)$Order = Champ(s) de tri
	*				(string|array)$GroupBy = Champ(s) à grouper
	*				(string)$Limit = Limitation de la requête
	*	Return	:	(array)résultat de la requête
	**/
	public function GetFrom($Table, $Fields = false, $Order = false, $Where = false, $GroupBy = false, $Limit = false)
	{
		//On initialise une nouvelle requête
		$Sql = '';
		//On créé la requête section par section
		//Section SELECT
		$Sql .= $this->MakeSQLPart('SELECT', $Fields?$Fields:'*');
		//Section FROM
		$Sql .= $this->MakeSQLPart('FROM', $Table);
		//Section WHERE
		$Sql .= $this->MakeSQLPart('WHERE', $Where);
		//Section ORDER BY
		$Sql .= $this->MakeSQLPart('ORDER BY', $Order);
		//Group By s'il y a
		$Sql .= $this->MakeSQLPart('GROUP BY', $GroupBy);
		//Limit s'il y a
		$Sql .= $this->MakeSQLPart('LIMIT', $Limit);
		//On retourne le tableau de résultat renvoyé par la fonction Query2Array();
		return $this->Query2Array($Sql);
	}
	
	/** Fonction GetValue
	*	Desc	: 	Retourne une valeur recherchée dans la base
	*	Params	: 	(string)$Table = Table SQL
	*				(string|array)$Field = Champ recherché
	*				(string|array)$Where = Critère WHERE
	*	Return	:	(string)valeur trouvée, sinon false
	**/
	public function GetValue($Table, $Field, $Where)
	{
		//On requête pour obtenir la valeur recherchée
		$result = $this->GetFrom($Table, 'DISTINCT('.$Field.')', false, $Where);
		//Si la requête a renvoyé un résultat
		if (count($result) === 1) {
			//On vérifie si la variable $Field a été renseigné avec la table
			//Du type matable.monchamp
			//On récupère la position du point
			$PositionPoint = strpos($Field, '.');
			//Et on déduit le nom du champ
			$FieldName = substr($Field, $PositionPoint ? $PositionPoint + 1 : 0);
			//On retourne la valeur recherchée
			return $result[0][$FieldName];
		} else {
			//Sinon il n'y a aucun ou plus d'un résultat donc on retourne false
			//Car on veut retourner une et une seule valeur
			return false;
		}
	}
	
	/** Fonction InTable
	*	Desc	:	Indique si une valeur est contenue par la table et le champ donné
	*	Params	:	(string)$Needle = valeur recherchée
	*				(string)$Table = nom de la table
	*				(string)$Field = nom du champ
	*				(bool)$Strict = si vaut true, recherche la valeur exacte
	*	Return	:	(bool)true si la valeur a été trouvée, sinon false
	**/
	public function InTable($Needle, $Table, $Field, $Strict = false)
	{
		//On recherche la valeur $Needle dans la table $Table et le champ $Field
		$result = $this->GetFrom($Table, $Field, false, $Field.'` LIKE "'.($Strict?$Needle:'%'.$Needle.'%').'"');
		//S'il y a au moins un resultat, on retourne true sinon false
		return count($result) ? true : false;
	}
	
	/**	Fonction LastInsertId
	#	Desc	:	Retourne l'id du dernier enregistrement inseré
	*	Params	:	None
	*	Return	:	(int)ID du dernier enregistrement inséré
	**/
	public function LastInsertId()
	{
		//Requête permettant de récupérer le dernier id inséré
		$sql = 'SELECT LAST_INSERT_ID() as last_id';
		$query = $this->connection->query($sql);
		//On retourne le résultat de la requête
		return $query->fetchColumn();
	}
	
	/**	Fonction Query
	*	Desc	:	Execute une requête SQL
	*	Params	:	(string)$sql = Requête SQL
	*	Return	:	(int)Nombre d'enregistrements affectés par la requête
	**/
	public function Query($Sql)
	{
		//On enregistre la requête pour pouvoir la ressortir au besoin
		$this->sql = $Sql;
		
		try {
			//On execute la requête
			$query = $this->connection->exec($this->sql);
			//Si une erreur s'est produite
			if (($error = $this->GetError()) !== false)
			{
				//On annule la transaction
				$this->RollBackTransaction();
				//On retourne l'erreur
				Throw new Exception($error);
			}
			else
				//Sinon on renvoie le résultat de la requête (nombre d'enregistrements affectés)
				return $query;
		} catch(Exception $e) {
			//On affiche le message d'erreur
			echo 'Une erreur s\'est produite lors de la validation de la requ&ecirc;te : <b>'.$e->getMessage().'</b>';
			//On retourne false
			return false;
		}
	}
	
	/** Fonction Query2Array
	*	Desc	:	Retourne sous forme de tableau le résultat d'une requête de sélection
	*	Params	: 	(string)$sql = Requête SQL
	*	Return	:	(array)Résultat de la requête, sinon false en cas d'erreur
	**/
	public function Query2Array($Sql)
	{
		//On enregistre la requête pour pouvoir la ressortir au besoin
		$this->sql = $Sql;
		
		try {
			//On execute la requête
			$query = $this->connection->query($this->sql);
			//Si un erreur s'est produite
			if (($error = $this->GetError()) !== false)
			{
				//On retourne l'erreur
				Throw new Exception($error);
			}
			else
				//Sinon on retourne le tableau de résultat
				return $query->fetchAll(PDO::FETCH_ASSOC);
		} catch (Exception $e) {
			//On affiche le message d'erreur
			echo 'Erreur de requ&ecirc;te SQL : <b>'.$e->getMessage().'</b><br />Rappel de la requ&ecirc;te : <b>'.$this->sql.'</b>';
			//On retourne false
			return false;
		}
	}
	
	/** Fonction RollBackTransaction
	*	Desc	: 	Annule une transaction MySQL
	*	Params	:	None
	*	Return	:	Void
	**/
	public function RollBackTransaction()
	{
		//Si une transaction est active
		if ($this->ActiveTransaction)
		{
			//On l'annule
			if ($this->connection->rollBack())
			//Et on modifie le tag de transaction
				$this->ActiveTransaction = false;
		}
	}
	
	/** Fonction GetError
	*	Desc	:	Renvoi le dernier message d'erreur formaté
	*	Params	:	None
	*	Return	:	(string)Message d'erreur
	**/
	private function GetError()
	{
		//On récupère les informations sur l'erreur
		$ErrorMessage = $this->connection->errorInfo();
		//S'il n'y a pas d'erreur
		if ($ErrorMessage[0] === '00000')
			//On retourne false
			return false;
		else
			//Sinon on retourne le message d'erreur formaté
			return "<p>Error : ".$ErrorMessage[0]." ".$ErrorMessage[1]." ".$ErrorMessage[2]."<br />SQL : ".$this->sql."</p>";
	}
	
	
	/** Fonction MakeSQLPart
	*	Desc	:	Constructeur de requête SQL
	*	Params	:	(string)Section à créer (SELECT, FROM, WHERE, ORDER BY, GROUP BY, LIMIT)
	*				(string|array)Contenu de la section à créer
	*	Return	:	(string)Partie de la requête demandée, sinon false
	**/
	private function MakeSQLPart($Part, $Values)
	{
		//Sections disponibles à la création
		$AllowedParts = array('SELECT', 'FROM', 'WHERE', 'ORDER BY', 'GROUP BY', 'LIMIT');
		//Initialisation de la requête
		$Sql = '';
		//Si la section demandée fait bien partie des sections disponibles
		if (in_array($Part, $AllowedParts))
		{
			//Si le contenu n'est pas vide
			if (!empty($Values))
				//On créer la requête en ajoutant la section demandée
				$Sql .= ' '.strtoupper($Part).' ';
			else
				//Sinon le contenu est vide alors on retourne une chaine vide
				return $Sql;
			
			//Si le contenu est un tableau
			if (is_array($Values))
			{
				//On prépare le séparateur
				//Si la section demandée est WHERE
				if ($Part == 'WHERE')
					//Le séparateur sera AND
					$separator = ' AND ';
				else
					//Sinon ce sera une virgule
					$separator = ', ';
				//Clé pour connaitre la position dans le tableau
				$Key = 1;
				//On parcours le tableau
				foreach ($Values as $Value)
				{
					//On ajoute la valeur courante du tableau
					$Sql .= $Value;
					//Si nous ne sommes pas à la fin du tableau
					if (($Key) != count($Values))
						//On ajoute le séparateur
						$Sql .= $separator;
					//On incrémente de un pour l'élément suivant
					$Key++;
				}
			}
			else
				//Sinon le contenu est une chaine alors on l'ajoute directement à notre morceau de requête
				$Sql .= $Values;
			//Et on retourne le morceau de requête construit
			return $Sql;
		}
		else
			//Sinon si la section demandées n'est pas dans les sections disponibles, on retourne false
			return false;
	}
	
	
	/** Fonction GetLastSql
	*	Desc	:	Retourne la dernière requête exécutée.
	*	Params	:	None
	*	Return	:	(string)Dernière requête SQL executée
	**/
	public function GetLastSql () {
		return $this->sql;
	}
}
?>