Pour continuer à parler CodeIgniter, on va aujourd’hui s’intéresser à la construction de requêtes SQL via les fonctions disponibles avec CodeIgniter et voir l’intêret d’utiliser ces fonctions lorsqu’on interroge une base de données.

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) ^^