Une fois le client satisfait, il nous donne le « Go » pour la mise en ligne, nous transférons alors les fichiers et la base de données sur le domaine final. Parfois, les URLs générées dans le contenu des pages sont erronées suite au transfert sur le domaine définitif, et bien entendu les liens foirent… En PHP, on pourrait faire un bête str_replace(), ou un preg_match_all(). Mais en MySQL ? C’est là que la requête qui suit va nous sauver :

UPDATE pages SET contenu = REPLACE(contenu, 'http://ancienne.url', 'http://nouvelle.url') WHERE contenu LIKE '%ancienne.url%';

C’est bidon, mais j’ai toujours du mal à m’en souvenir. Le publier ici me permettra de retrouver ça facilement. Après tout, ce blog est avant tout pour moi et si ça peut aider quelqu’un d’autre… 

Du coup, je cherchais un moyen de supprimer les adresses mails mal formatées qu’on trimbale, et par la même occasion, récupérer seulement les adresses mails bien formatées lors de l’envoi de la newsletter, en attendant que l’on fasse un beau remodeling du site actuel.

Du coup, je m’suis demandé tout bêtement, si MySQL prenait en compte les expressions régulières, ce qui m’aurai facilité le travail. Et bien sachez le, c’est carrément possible (youpi!) et super simple à mettre en oeuvre en plus. Voilà comment :

Dans un SELECT

Utile si vous voulez récupérer tous les champs validant l’expression régulière

SELECT 'fofo' REGEXP '^fo' FROM table;

Dans une clause WHERE

En fait, ça ne change pas grand chose

SELECT champ FROM table WHERE champ REGEXP '^([a-z0-9_.-]+)@([da-z.-]+).([a-z.]{2,6})$' AND champ2 REGEXP '(chouette|cool|super)'

Alors, heureux? 

Ok, avant de voir comment utiliser CodeIgniter pour exécuter des requêtes SQL, on va voir comment déclarer plusieurs configuration de base de données, pour par exemple avoir une configuration différente selon si l’on travaille en local ou bien sur serveur.

Configurer la classe Database

Afin de permettre à CodeIgniter de « discutailler » avec notre base de données, il faut lui donner les infos pour y accéder. Ouvrez le fichier database.php se trouvant dans le dossier config de l’application (application/config/database.php), vous trouverez les réglages de la base de données stockés dans un  tableau multidirectionnel $db comme ci-dessous.

$dbconf['default']['hostname'] = "localhost";
$dbconf['default']['username'] = "root";
$dbconf['default']['password'] = "";
$dbconf['default']['database'] = "database_name";
$dbconf['default']['dbdriver'] = "mysql";
$dbconf['default']['dbprefix'] = "";
$dbconf['default']['pconnect'] = TRUE;
$dbconf['default']['db_debug'] = FALSE;
$dbconf['default']['cache_on'] = FALSE;
$dbconf['default']['cachedir'] = "";
$dbconf['default']['char_set'] = "utf8";
$dbconf['default']['dbcollat'] = "utf8_general_ci";

L’intérêt d’utiliser un tableau multidirectionnel pour enregistrer les infos relatives à la base de données, c’est de pouvoir définir un autre tableau  avec des informations différentes, pour ensuite choisir lequel de ces tableaux utiliser. Ainsi, si l’on souhaite déclarer deux configurations différentes, rien de plus simple :

//config par défaut
$db['default']['hostname'] = "localhost";
$dbconf['default']['username'] = "root";
$dbconf['default']['password'] = "";
$dbconf['default']['database'] = "database_name";
$dbconf['default']['dbdriver'] = "mysql";
$dbconf['default']['dbprefix'] = "";
$dbconf['default']['pconnect'] = TRUE;
$dbconf['default']['db_debug'] = FALSE;
$dbconf['default']['cache_on'] = FALSE;
$dbconf['default']['cachedir'] = "";
$dbconf['default']['char_set'] = "utf8";
$dbconf['default']['dbcollat'] = "utf8_general_ci";

//config secondaire
$dbconf['test']['hostname'] = "host_name";
$dbconf['test']['username'] = "db_user";
$dbconf['test']['password'] = "db_pass";
$dbconf['test']['database'] = "database_name";
$dbconf['test']['dbdriver'] = "mysql";
$dbconf['test']['dbprefix'] = "";
$dbconf['test']['pconnect'] = TRUE;
$dbconf['test']['db_debug'] = FALSE;
$dbconf['test']['cache_on'] = FALSE;
$dbconf['test']['cachedir'] = "";
$dbconf['test']['char_set'] = "utf8";
$dbconf['test']['dbcollat'] = "utf8_general_ci";

Il suffira ensuite de définir la valeur de la variable $active_group à « test » pour utiliser notre configuration secondaire. Easy!

Pour établir la connexion à la base de données il faudra alors faire appelle à la librairie Database dans votre classe, grâce à la ligne suivante :

$this->load->database($dbconf);

Il est aussi possible d’instancier deux connexion en faisant comme suit :

$db1 = $this->load->database('default');
$db2 = $this->load->database('test');

Ma première requête SQL avec CodeIgniter

On y est, notre connexion à la base est active, on va pouvoir manipuler les données (j’adore ça, manipuler des données)!

Avec CodeIgniter, ce qu’il y a de bien c’est qu’on a vraiment le choix des armes pour construire nos requêtes : soit on les construit comme au bon vieux temps des mysql_*() soit on utilise la méthode objet (PDO), ou encore mieux on utilise les nombreuses fonctions du Framework!

Comme il y a toute une flopée de fonctions préexistantes je vais volontairement ne présenter que les plus courantes.

mysql_query() à la sauce CI

C’est la fonction query() de la classe Database qui permet d’exécuter simplement des requêtes SELECT simple. La fonction s’utilise très simplement : $this->db->query('SELECT * FROM table');

Si l’on souhaite construire des requêtes avec paramètres, il sera obligatoire de les échapper avec les fonction escape(), escape_str() ou escape_like_str(), équivalents de la fonction mysql_real_escape_string().

La fonction escape() permet d’échapper les données quelque soit leur type (string, int, float, etc…), tandis que escape_str() n’accepte que des données de type string. escape_like_str() quant à elle, permet d’échapper des requêtes avec des conditions LIKE.

Query() peut aussi être utilisé avec des requêtes préparées, comme avec l’objet PDO. Ainsi pour exécuter une requête, rien de bien compliqué:

$sql = "SELECT * FROM some_table WHERE id = ? AND status = ? AND author = ?";
$this->db->query($sql, array(3, 'live', 'Rick'));

L’intérêt ici, comme avec PDO c’est que les valeurs passées en paramètre sont automatiquement échappées.

CodeIgniter pourrait s’arrêter là, mais dans ce cas qu’aurait-il de plus que le simple objet PDO ? La réponse : l’Active Record!

La classe Active Record

Utiliser l’Active Record, c’est hype, branché et trop in the move!

Pourquoi? Parce que cela permet entre autre de laisser de côté l’histoire « Ma base est en MySQL, SQL Server, Postgre, … ? », en clair on ne s’occupe pas du SGBD utilisé, on lui pose juste les questions. Conséquence, notre appli a une meilleure portabilité.

CodeIgniter propose pas mal de fonctions permettant de construire des requêtes sans se fouler, j’irai même jusqu’à dire « sans même en connaître un radis en SQL ». Regardons ce qui nous est proposé.

$this->db->get()

get() permet d’exécuter en un rien de temps un SELECT sur une table et ainsi retourner tout ses enregistrements

$query = $this->db->get('mytable');
// équivalent: SELECT * FROM mytable

Si l’on veut limiter le nombre de résultats retournés, par exemple dans le cadre d’une pagination, rien de plus simple il suffit juste de passer deux autres paramètres à get() en plus de la table sur laquelle on travaille.

$query = $this->db->get('mytable', 10, 20);
// équivalent : SELECT * FROM mytable LIMIT 20, 10

$this->db->get_where()

Vraiment besoin d’explications? get_where() permet tout simplement de faire un get() avec des conditions.

Les différentes condition seront à présenter sous forme d’un tableau (on vera ça ensuite dans la fonction where()) .

$query = $this->db->get_where('mytable', $where, $limit, $offset);

Avec ces deux fonctions, c’est le Framework qui s’occupe de construire nos requêtes. Si l’on veut les générer nous même tout en utilisant l’Active Directory, c’est maintenant qu’on va retrouver une pelletée  de méthodes.

SELECT, FROM, WHERE

Ok, admettons que l’on veuille retourner le titre, le contenu et la date d’un article dans notre base.

Clairement ici get_where() boufferai de la ressource inutilement puisqu’il nous retournerai d’autres champs dont on aurait pu se passer. select() est là pour nous ravir les amis!

$this->db->select('title, content, date');
$query = $this->db->get('articles');
// équivalent: SELECT title, content, date FROM articles

Attends voir, là on récupère le titre, le contenu et la date de tout les articles dans la base… Quel œil vif! C’est ici qu’interviennent nos amis from() et where() :

$this->db->select('title, content, date');
$this->db->from('articles');
$this->db->where(array('id' => 7));
$query = $this->db->get();

C’est pas beautiful ? CodeIgniter a un sac plein de fonctions équivalentes aux fonction SQL comme SUM(), AVG(), COUNT(), etc.  Je ne les traiterai pas ici mais vous pourrez les retrouver sur dans le Guide Utilisateur de CodeIgniter.

Chose pratique, on peut concaténer toutes ses fonctions, pour économiser en ligne de code. Ainsi, notre requête précédente pourrait s’écrire :

$this->db->select('title, content, date')->from('articles')->where(array('id' => 7));
$query = $this->db->get();

Affichage des résultats

On finira ce billet très rapidement sur la façon d’afficher le résultat de nos différentes requêtes.

Ici on fera un simple foreach() comme on a l’habitude d’en faire quand on utilise PDO (pour moi en tout cas).

$query = $this->db->get('mytable');
foreach ($query->result() as $row){
  echo $row->title;
}

Conclusion

Ici on a donc vu pas mal de méthodes bien utile lorsqu’il s’agit d’interroger une base de donnée lorsqu’on développe dans le cadre d’une application Web sous CodeIgniter.

Petite parenthèse, je tiens à m’excuser pour l’attente interminable entre le moment ou j’ai annoncé faire cet article, et sa publication. J’ai eu deux bons gros mois de taff bien chargés, autant au boulot, qu’au niveau perso (notamment le site du WDFR sur lequel je travail avec @Fran6, @Twikito, @ClementRoy et @C_Beghin, et tout le workgroup WDFR), ce qui explique en partie ce petit retard.

J’en profite aussi pour souhaité avec du retard, une très bonne année 2011, pleine de bonnes choses et d’argent (surtout) ^^

Qu’est-ce que c’est un objet PDO?

PDO pour PHP Data Objects, pour faire simple donc, les discussions avec notre base de données se feront avec la notion d’Objet, pour ceux qui ne voient pas ce qu’est la programmation orientée objet, direction Wikipedia.

Qu’est-ce que ça change?

Tout! Avec PDO, on ne s’embête plus à faire un gros script qui gère le fait que l’on utilise une base de donnée MySQL, SQL Server, PostgreSQL, Oracle, etc… Ici, nous n’avons besoins de changer que quelques parametres, et zou! on utilise les même methodes partout dans notre projet PHP. PDO permet donc une meilleure portabilité d’un programme sur un autre environemment que celui pour lequel il a été développé.

Comment utiliser PDO ?

Mieux qu’une explication à rallonge, on va voir ici un exemple de connexion simple à une base MySQL sans utiliser PDO, et ensuite en utilisant PDO, pour bien mettre en evidence l’avantage d’utiliser PDO pour nos prochains projets.

Imaginons qu’on est une base de données nommée « dbtest », contenant la table « tbltest » construite de la façon suivante :

CREATE TABLE tbltest (
id int NOT NULL auto_increment,
login varchar(50),
pass varchar(255),
email varchar(200),
PRIMARY KEY(id)
);

En utilisant les fonctions mysql_* il nous faut écrire pas mal de code pour se connecter à la base et executer une requête :

<?php
$db = mysql_connect('localhost','login','password'); //connexion à  MySQL
mysql_select_db('dbtest',$db); //séléction de la base sur laquelle on va travailler
$strSQL = "SELECT login,pass,email FROM tbltest"; //notre requête
$result = mysql_query($strSQL) or die('Erreur '.mysql_error()); //execution de la requête
//affichage des résultats
while($row = mysql_fetch_assoc($result)){
echo $row['login']." ".$row['pass']." ".$row['email']."<br/>";
}
mysql_close();
?>

Maintenant, voyons comment executer cette même requête avec un objet PDO :

<?php
try {//creation de l'objet PDO
$db = new PDO('mysql:host=localhost;dbname=dbtest','login','password');
$strSQL = "SELECT login,pass,email FROM tbltest";
//execution de la requête et affichage des résultats
foreach($db->query($strSQL) as $row){
echo $row['login']." ".$row['pass']." ".$row['email']."<br/>";
}
} catch (PDOException $e){ //erreur de connexion à la basse
print "Erreur : ".$e->getMessage()
die();
}
$db = null; //on ferme la connexion
?>

L’avantage de PDO : les requêtes préparées

Bien que l’exemple plus haut soit un exemple basique, PDO permet d’exécuter des requêtes préparées et c’est tout l’interet de la chose. En effet, les requêtes préparées permettent un gain de temps puisque nous utilisons une espèce de « patron » pour construire notre requête, et lors de l’exécution de celle-ci, on passe un tableau de paramètres. Ainsi on peut executer la même requête plusieurs fois avec différents paramètres très facilement et rapidement.

Executer une requête préparée

Pour construire et executer une requête préparée nous aurons besoin de la fonction prepare() de l’objet PDO, cette fonction retournera un objet PDOStatment, qui nous permettra d’executer la requête en lui passant les paramètres avec la fonction execute().

Il est a noter que l’on peut préparer une requête de plusieurs manières : grâce à des marqueurs (?) ou des paramètres nommées (:nom_parametre)

<?php
//création de la requête avec la methode des marqueurs
$strSQL = "SELECT login,pass,email FROM tbltest WHERE login = ? AND pass = ? ";
//requête construite avec les paramètres nommés
//$strSQL = "SELECT login,pass,email FROM tbltest WHERE login = :login AND pass = :pwd ";

$stmt = $db->prepare($strSQL); // création de l'objet PDOStatment
$stmt->execute(array('mon_login','mon_password'));
//execution avec la methode des paramètres nommés
//$stmt->execute(array(':login' => 'mon_login', ':pwd' => 'mon_password'));

//affichage du résultat
while($row = $stmt->fetch(PDO::FETCH_OBJ)){
echo $row->login." ".$row->pass." ".$row->email."<br/>";
}
?>

Pour plus d’infos sur l’objet PDO rendez vous sur le site du manuel PHP ]]> https://chierchia.fr/2009/08/utiliser-pdo-pour-les-connexion-a-une-bdd/feed/ 0