My Favourite MYSQL functions

Se Connecter à une base

Commençons par le commencement, si vous voulez interagir avec une base, la première chose à faire est de s'y connecter en utilisant les fonctions natives mysql_select_db() et mysql_connect(), qui peuvent utiliser pas moins de 5 paramètres. Si vous réécrivez la procédure entière à chaque fois que vous compter établir une connexion, c'est une pure perte de temps , et ce sera un cauchemar à maintenir. La solution? Placez tout le code nécessaire dans une fonction connect() comme la suivante:

function connect()
{
  $HOST="dbhost";
  $PORT="dbport";
  $DB_USER="dbusername";
  $DB_PWD="dbpassword";
  $DB_BASE="dbname";		  
  $DB_HOST = (!empty($PORT)) ? $HOST.":".$PORT : $HOST;
  return $connection = mysql_select_db(
    $DB_BASE,mysql_connect($host,$DB_UTILISATEUR,$DB_MDP)
  );    
}
//Example of use:
connect();

Comme vous pouvez le voir entre les lignes 3 et 7, on spécifie les paramètres qui seront utilisé pour la connexion, (serveur, port, utilisateur, mot de passe et nom de la base). Ligne 8, on précise juste que si un port est utilisé, on se connectera via ce port sur le serveur.

Ensuite, on tente de se connecter à la base et on retourne le résultat. A partir de ce moment, à chaque fois que vous voulez établir une connexion, il vous suffit de faire appel à la fonction connect().

Requêtes simples

Ce qui est intéressant avec la fonction mysql_query(), c'est que vous pouvez l'utiliser pour réaliser un grand nombre d'opérations, comme par exemple exécuter toutes les requêtes qui nous intéressent actuellement.

Du coup, personnellement, j'aime bien avoir une fonction query() à part au cas j'ai besoin d'envoyer une requête particulière à la base, mais je ne l'utilise pas pour les interactions usuelles.

function query($sql)
{
  if(mysql_query($sql)) { return true; } 
  else { die("SQL Error: <br>".$sql."<br>".mysql_error()); return false; }
}
//Example of use:
$sql = "USE mydb";
query($sql);

Très simplement, si la requête est valide, la fonction retourne true, sinon, elle affiche un message pour vous montrer ce qui n'est pas allé et retourne false.

La requête Select

Le fait de sélectionner des données à partir d'une table peut être résumé en quelque étapes. Premièrement, il faut écrire la requête afin de préciser les données que l'on veut obtenir. Ensuite, il faut envoyer cette requête à la base, et finalement, récupérer les résultats afin de pouvoir les exploiter. Quand on y pense, 2 de ces 3 étapes sont assez similaires et peuvent donc être réutilisées dans une fonction plutôt que d'être répétées à chaque fois.

La fonction select() suivante, prends en paramètre votre requête sql, et vous retourne un array de résultats que vous pouvez utiliser immédiatement:

function select($sql)
{
  $result=array();
  $req = mysql_query($sql) or die("SQL Error: <br>".$sql."<br>".mysql_error());
  while($data= mysql_fetch_assoc($req)) {
    $result[]=$data;
  }
  return $result;
}
//Example of use:
$sql = "SELECT * FROM mytable";
$results = select($sql);
print_r($results);

La requête est envoyée à la base ligne 4, grâce à la fonction mysql_query(). S'il y a un problème quelconque, la fonction vous le dira donc vous pourrez apporter les corrections nécessaires, sinon lignes 5 à 7, on boucle parmis les résultats et on les stock au passage dans un array. Cet array qui contient donc les données que vous recherchiez vous est finalement retourné ligne 8. Cette fonction est vraiment pratique et facile à utiliser. Il suffit de lui envoyer votre requête et vous savez que vous obtiendrez les résultats recherché à l'autre bout.

La requête Insert

Ce qui m'ennuie le plus avec la requête insert, est qu'elle est assez fastidieuse à construire. Il faut copier, et associer chaque nom de champ avec leur valeur et quelque fois, cela donne des requêtes vraiment longues. Je trouve cela beaucoup plus simple et pratique de travailler avec des arrays php à 2 dimensions plutôt qu'avec une chaine de caractères.

C'est avec ce principe en tête que la fonction insert() à été construite. Elle prend en paramètre, un nom de table, et un array, dont les clés sont en fait les noms de champs. En d'autres termes, il suffit de construire un array sur le format array('field-1'=>'value-1', ..., 'field-n'=>'value-n'), et puis de le passer à la fonction, qui va tout d'abord construite la requête à partir de cet array, et ensuite insérer les valeurs dans la table.

function insert($table,$data)
{
  $fields=""; $values="";
  $i=1;
  foreach($data as $key=>$val)
  {
    if($i!=1) { $fields.=", "; $values.=", "; }
    $fields.="$key";
    $values.="'$val'";
    $i++;
  }
  $sql = "INSERT INTO $table ($fields) VALUES ($values)";
  if(mysql_query($sql)) { return true; } 
  else { die("SQL Error: <br>".$sql."<br>".mysql_error()); return false;}
}
//Example of use:
$data = array(
	"field1"=>"value1",
	"field2"=>"value2",
	"field3"=>"value3",
);
insert("mytable",$data)

A partir du code de la fonction, on peut voir entre les lignes 5 et 11, on utilise l'array pour construire 2 chaines. La chaine fields est fait avec les clés du tableau, et la chaine values est faite avec les valeurs correspondantes. Grâce à cet approche, les champs et leur valeur sont toujours associés par paire et d'une façon dynamique, ce qui est bien plus facile pour travailler.

Une fois la requête générée, elle est envoyé à la base ligne 13.

La requête Update

Puisque cette requête est assez similaire à Insert, j'avais les mêmes problèmes qu'avec elle dans le passé, c'est à dire que je trouvais cela pas très convéniant à construire. Mais puisque c'est similaire, cela veut aussi dire, qu'il est possible de traiter le problème avec la même approche, en travaillant avec un array pour commencer, et en envoyant cet array à une fonction qui s'occupe du reste.

La différence notable, c'est l'apparition d'un 3eme paramètre, appelé $where qui contient une chaine qui vous permet de spécifier précisément où appliquer les changements, comme par exemple 'fieldid = 1'. C'est équivalent au WHERE que l'on trouve dans les requêtes udpates habituellement.

public function update($table,$data,$where)
{
  $modifs="";
  $i=1;
  foreach($data as $key=>$val)
  {
    if($i!=1) { $modifs.=", "; }
    if(is_numeric($val)) { $modifs.=$key.'='.$val; }
    else { $modifs.=$key.' = "'.$val.'"'; }
    $i++;
  }
  $sql = ("UPDATE $table SET $modifs WHERE $where");
  if(mysql_query($sql)) { return true; } 
  else { die("SQL Error: <br>".$sql."<br>".mysql_error()); return false; }
}
//Example of use:
$newdata = array(
	"field1"=>"newvalue1",
	"field2"=>"newvalue2",
	"field3"=>"newvalue3",
);
update("mytable",$newdata,"myfieldid = 1");

Dans le même esprit que la fonction isert(), lignes 5 à 11, l'array est utilisé afin de construire la requête update. Les modifications sont associées par paires afin de construire la chaine $modifs. Ces modifications sont ensuite appliquées aux champs ciblés par la clause where.

La requête Delete

Cette requête est plus basique que les précédentes. La fonction delete() suivante prend 2 paramètres, le nom de la table dans laquelle les données seront supprimées, et une chaine where vous permettant de spécifier la condition de suppression comme dans une requête where normale (par ex: fieldid = 1).

A partir de ces paramètres, la fonction va générer la requête delete, et supprimer les données correspondantes.

public function delete($table, $where)
{
  $sql = "DELETE FROM $table WHERE $where";
  if(mysql_query($sql)) { return true; } 
  else { die("SQL Error: <br>".$sql."<br>".mysql_error()); return false; }
}
//Example of use:
delete("mytable","myfieldid = 1")

Conclusion

Le fait d'utiliser des fonctions personnalisées pour s'occuper interactions de bases de données est très pratique en terme de maintenance et d'optimisation de code, car vous n'avez pas à écrire, copier et coller les mêmes requêtes à chaque fois que vous en avez besoin. Il suffit d'appeler une fonction, et vous savez que celle ci s'occupera de générer la bonne requête, l'enverra à la base, et obtiendra le résultat. C'est aussi très pratique quand vous désirez modifier le code sql à l'intérieur de ces fonctions car vous n'avez à le faire qu'à un seul endroit au lieu de devoir chercher partout dans votre code afin d'apporter les modifications.

Finalement, je trouve cela plus pratique de travailler avec des arrays php et de les passer à des fonctions plutôt que de devoir écrire les requêtes correctes à chaque fois. Ces fonctions peuvent facilement être améliorées. J'ai par exemple à ma disposition une classe 'database' qui comprend toutes ces fonctions. J'espère que vous trouverez ces fonctions aussi utiles que moi.

Partager:

Vous seriez peut être aussi intéressé par::

Poster un Commentaire

Commentaires récents

@Amit.

Hey Amit, I'm glad you like them, it will save you loads of time you'll see.

The line you don't understand adds commas in the fields string and values string before each element but the first.

In other words, if you are using :

$newdata = array(
"field1"=>"newvalue1",
"field2"=>"newvalue2",
"field3"=>"newvalue3",
);


It will generate $fields = field1 comma field2 comma field3. The particular line will add a comma before field2 and field3, but not before field1 because at this stage $i = 1.
Same for $values which will be value1 comma value2 comma value3.

Does that make sense?

De jdmweb à 10:55 21/04/10 { Répondre }

This is really great. I am going to start using these right away.

In the Insert function, could you explain the i iterator though, I know its a counter that is holding the current value of the array through each loop. But I don't understand the
if($i!=1) { $fields.=", "; $values.=", "; }. Why is this needed?

What does it do?

De Amit à 06:09 21/04/10 { Répondre }

These are very noteworthy functions for anyone delving into coding , MSQL and all things Wordpress ( especially ) ; Being a Noob myself , this info is invaluable to me - and thank you for making the effort of putting this together ( quite meticulously I would say ) .
You are also a great instructor , aside from your other skills .
Thank You for this article & the data resource :)
Mia

De MiaZoe à 02:02 18/04/10 { Répondre }