Php propose deux fonctions aussi puissantes qu’utiles (mais aussi méconnues) : serialize et unserialize.

• Serialialize compresse (linéarise) un tableau Php
• Unserialize le décompresse (ou délinéarise), tout simplement.

A partir de là, l’idée paraît s’imposer d’elle même : pour certaines requêtes qui sont énormément exécutées et/ou qui sont très lourdes (par exemple les données d’un membre utilisées sur toutes les pages d’un site), pourquoi ne pas mettre en cache le tableau issu d’un mysql_fetch_array() ? Ainsi, une fois que la requête a été exécuté on n’accède plus à la base de donnée, on récupère le tableau de données dans un fichier texte puis on le décompresse.

La première fonction permet, tout simplement, d’écrire dans un fichier (en le créant, le cas échéant) :

<?
function maj_fichier($file,$valeur)
{
$fp = fopen("$file","w+"); // ouverture du fichier en écriture (on le créé s'il n'existe pas)
fputs($fp, $valeur); // on écrit dans le fichier
fclose($fp);
}
?>

La seconde – et c’est la fonction qui nous intéresse – est la fonction de mise en cache :

(pour l’utiliser vous aurez besoin de la fonction maj_fichier() ci-dessus et de la fonction requete_sql disponible sur ce billet)

<?
function MiseEnCache($nomFichier,$table,$where,$champs)
{

if(file_exists($nomFichier)) // si les variables sont en cache
{
$requete = unserialize(lire_fichier($nomFichier)); // on utilise le fichier cache (unserialize = decompresser le tableau)
}
else // sinon on fait la requete sql
{
$requete = requete_sql($table, $champs, $where);
maj_fichier($nomFichier, serialize($requete)); // on place le resultat du tableau dans un fichier (serialize = compresser le tableau)
}

return $requete;
}
?>

Exemple d’utilisation :

<?
$req_membre=MiseEnCache("/cache/membres/membre-".$id_membre.".txt","membres", "id='$id_membre'", "prenom,nom,date_inscription,login");

echo »Bienvenue « .$req_membre[prenom]. » « .$req_membre[nom]. » ! »;
?>

Cet exemple permet de pouvoir afficher sur toutes les pages le prénom et le nom du membre en effectuant la requête qu’une seule fois ! Malin n’est-ce pas ?

Mais bien sur vous-vous dites : et si le membre modifie son nom, l’information sera erronée ?

La réponse est simple : il suffit de supprimer le fichier texte lors de la modification des informations pour le régénérer avec les bonnes !!

Il y a néanmoins une limitation à l’utilisation de ce procédé : ne l’utilisez pas pour des données sensibles (mot de passe, email, etc.) car un fichier texte est beaucoup plus facilement accessible pour un pirate qu’une base de données…

J’ai longuement cherché sur le web, et je n’ai trouvé que peu d’infos à ce sujet. Je vous livre ici le résultat de mes recherches et de mes multiples tests, de l’intégration des coordonnées de latitude/longitude à l’aide des API de géolocalisation google map et yahoo map jusqu’à la requête sql finale qui inclue la formule de calcul de distance à partir des coordonnées géolocalisées.

Une base de donnée fiable des villes associées à leurs coordonnées de latitude/longitude

En premier lieu, il s’agit d’avoir une base de données de villes. Il en existe de nombreuses sur le net, celle-ci intègre même les coordonnées de latitude et de longitude.

Dans mon cas, je possédais déjà une base de données de villes françaises mais sans ces coordonnées. La meilleure méthode pour y intégrer la latitude et la longitude de chaque ville est d’utiliser l’API de Yahoo ou de google.

Ces deux API permettent de récupérer un flux XML correspondant à la recherche (ex : Amiens, France) contenant la latitude et la longitude.

Par exemple, voici le résultat de la recherche de la ville d’Amiens avec l’API de Yahoo :

<ResultSet xsi:schemaLocation="urn:yahoo:maps http://api.local.yahoo.com/MapsService/V1/GeocodeResponse.xsd">
<Result precision="zip">
<Latitude>49.896309</Latitude>
<Longitude>2.279720</Longitude>
<City>80000 Amiens</City>
<State>France</State>
<Country>FR</Country>
</Result>
</ResultSet>

Il n’y a donc plus qu’à faire une boucle sql sur la table des villes en parsant le flux de yahoo ou google correspondant (en indiquant la ville, le code postal et le pays) et intégrer à l’enregistrement de la ville la latitude et la longitude. Un vrai jeu d’enfant avec simplexml en php5 ! Cependant, même si ces API sont puissantes, il se peut que parfois la ville ne soit pas trouvée, que la ville retournée ne soit pas la bonne ou que plusieurs résultats soient retournés. Pour plus d’informations, et pour choisir entre les API de Yahoo et de Google, je vous invite à lire cet article sur la géolocalisation via yahoo et google map très bien fait et qui m’a bien aidé.

Vous avez à présent une table contenant les villes associées à leurs coordonnées géographique de latitude et de longitude.

Il ne reste plus qu’à exploiter cela dans une requête SQL et afficher le tout en PHP.

J’ai d’abord tenté une conversion des données latitude/longitude en points de coordonnées lambert 2 étendue (norme française) grâce à la fonction geos2lambert() disponible sur google code mais son exploitation s’est révélé compliquée et imprécise (ou alors c’est moi qui suis vraiment nul en maths !).

Je suis donc reparti sur les données de latitude/longitude. Grâce à une formule mathématique complexe trouvée sur le net je suis arrivé au résultat suivant.

Je reçois en variable GET les coordonnées de ma ville de référence :

$latitude=$_GET[lat];
$longitude=$_GET[lon];

La fameuse formule utilisant les colonnes lat et lon de ma table sql et les données de latitude et longitude de ma ville de référence :

$formule="(6366*acos(cos(radians($latitude))*cos(radians(`lat`))*cos(radians(`lon`) -radians($longitude))+sin(radians($latitude))*sin(radians(`lat`))))";

Et la requête SQL prête à être exécutée :

$sql="SELECT ville,$formule AS dist FROM ville WHERE $formule<='$_GET[distance]' ORDER by dist ASC";

• le SELECT $formule AS dist permet de classer les villes de la plus proche à la plus éloignée avec ORDER by dist ASC
• le WHERE $formule<=’$_GET[distance]‘ permet de définir un rayon en km ($_GET[distance]) à partir de la ville de référence

Je vous laisse coder l’éxécution de la requête sql et l’affichage des données en php, ce n’est pas vraiment le plus dur !

Vous pouvez voir le résultat sur cette page. La ville de référence est ici Amiens avec un périmètre de 15 km.

En guise de conclusion…

Il faut savoir que ce calcul et le résultat ne sont pas précis pour plusieurs raisons :

• Le calcul ne tient pas compte de l’altitude, qui, dans certains endroits peut influer sur les distances
• La formule a été simplifiée au maximum par souci de simplicité et d’efficacité.
• La distance est « à vol d’oiseau » et non pas une distance routière
• La localisation latitude/longitude d’une ville repose sur un point (généralement la mairie de la ville en question), donc la distance ne commence pas à la sortie de la ville mais du centre de la ville. Ainsi, par exemple, pour Paris cela ne sert à rien de vouloir localiser les villes à 5km…

Cependant, malgré l’imprécision cela fonctionne, car l’intérêt premier est d’afficher les villes proches et non de concurrencer google map ! Il convient juste de ne pas forcément afficher les distances en km qui sont souvent fausses (à quelques kilomètres près).

L’utilisation de cette technique qui est finalement assez simple à mettre en place peut être très utile sur du web local afin d’élargir les recherches sur une ville aux villes à proximité (dans le cas où aucune réponse n’est disponible pour la ville concernée par exemple) ou proposer d’autres villes ou contenus (ou publicités géolocalisées !) à l’internautes en rapport avec sa requête.

Si vous avez des questions sur la mise en place d’une recherche de proximité ou si cet article vous a aidé, n’hésitez pas, les commentaires sont fait pour ça !

Pour inaugurer cette partie, je vous fournis 4 fonctions (+ 2 variantes) bien utiles pour faire des traitements SQL de base à savoir : SELECT, INSERT, UPDATE et DELETE.

Ces fonctions sont finalement assez simples, mais ça fait gagner du temps. De plus, ce genre de fonction permet d’opérer des changements sur toutes les requêtes identiques très simplement (ex : en cas de changement de système de base de données).

Insérer un enregistrement :

function inserer_sql($table,$champs,$donnees)
{
$sql = "INSERT INTO $table ($champs) ";
$sql .= "VALUES ($donnees)";

if(mysql_query($sql))
{
return true;
}
else
{
return false;
}
}

Et pour l’utiliser, c’est tout aussi simple. Par exemple :

if(inserer_sql("utilisateurs","email,nom,prenom",
"'$_POST[email]','$_POST[nom]','$_POST[prenom]'"))
echo"L'ajout a été effectué avec succès";
else echo"L'ajout a échoué";

Ensuite, pour gagner du temps j’utilise une autre fonction qui n’a comme arguments que le nom de la table et la liste des champs à ajouter (sous forme de tableau). Cela suppose bien sur une correspondance des champs du formulaire (données POST) et des champs de la table :

function inserer_sql_array($table,$array)
{
$req="";
$i=1;
foreach($array as $k)
{

if($i!=’1′) { $req.= », « ; $req2.= », « ; }

$req.= »$k »;
$req2.= »‘$_POST[$k]‘ »;
$i++;
}

return inserer_sql($table,$req,$req2);
}

Il suffit de l’utiliser comme ceci :

if(inserer_sql_array("utilisateurs",array("email,nom,prenom"))
echo"L'ajout a été effectué avec succès";
else echo"L'ajout a échoué";

Modification de données :

Sur le même principe que pour l’ajout j’ai cette fonction :

function maj_sql($table,$action,$where)
{
if($where=='') { $where=1; }

$sql = « UPDATE $table SET $action « ;
$sql .= « WHERE $where »;

if(mysql_query($sql))
{
return true;
}
else
{
return false;
}
}

Dans cette fonction, il est permis de modifier tous les enregistrements d’une table (en laissant l’argument $where à vide). Mais, par mesure de sécurité, on peut désactiver cela en testant la variable $where au début et en renvoyant false si elle est vide.

Pour utiliser cette fonction, il suffit de tester que la fonction renvoie bien true.

La variante de cette fonction qui génère la requête à partir d’un tableau array() :

function maj_sql_array($table,$array,$where)
{
$req="";
$i=1;
foreach($array as $k)
{
if($i!='1') $req.=", ";

$req.= »$k=’$_POST[$k]‘ »;
$i++;
}

maj_sql($table,$req,$where);
}

Suppression de données :

Cette fonction permet de supprimer un ou plusieurs enregistrements dans une table en précisant uniquement la table et la condition à remplir. Cependant, par mesure de sécurité, il est impossible de ne pas préciser de condition (cela supprimerait tous les enregistrements de la table) :

function sup_sql($table,$where)
{

if($where== ») {
return false;
}
else
{
$sql = « DELETE FROM $table « ;
$sql .= « WHERE $where »;

if(mysql_query($sql))
{
return true;
}
else
{
return false;
}
}
}

Lire une ligne d’une table :

Enfin, la dernière fonction permet d’extraire les données d’un enregistrement d’une table. C’est bien sûr en fait un simple SELECT mais comme pour les autres fonctions, cela permet de gagner du temps.

function requete_sql($table,$champs,$where)
{
// si $where est vide on lui attribue une valeur par défaut
if($where=='') { $where=1; }

// en cas de jointure on utilise le nom de la première table pour le tri par ID.
$tab=explode(« , »,$table);

$sql = « select $champs from $table where $where ORDER by $tab[0].id DESC LIMIT 1″;
$p = mysql_query($sql)OR DIE(« Erreur sur la requete SELECT $champs FROM $table WHERE $where »);
return mysql_fetch_array($p);
}

Le résultat de cette fonction est un tableau contenant les données précisées dans l’argument $champs. Exemple :

$requete=requete_sql("utilisateurs","nom,prenom,email","id='$_GET[user]'");
echo"Bonjour ".$requete[prenom]." !";

En bonus, voici la fonction qui permet de compter le nombre d’enregistrements dans une table pour une condition précise. Cette fonction effectue un mysql_numrows sur une requête SELECT. Les puristes préféreraient sans doûte un SELECT count(id), cependant, il me semble que ma méthode est moins lourde :

function compter_sql($table,$where)
{
if($where=='') { $where=1; }
$sql = "select id from $table where $where";
$p = mysql_query($sql)OR DIE("Erreur sur la requete SELECT id FROM $table WHERE $where");
return mysql_numrows($p);
}

Cette fonction suppose que vous avez une colonne id dans votre table puisque le SELECT est effectué dessus. Pour l’utiliser, rien de plus simple :

$nb_utilisateurs_hommes = compter_sql("utilisateurs","sexe='H'");

Conclusion :

Ces petites fonctions ne sont pas révolutionnaires en soit puisqu’elles reprennent les principes de base de SQL. Cependant, et ce n’est pas négligeable, elles permettent réellement de gagner du temps car elles sont plus rapides à écrire et plus faciles à retenir (je retiens mieux des noms de fonction en français qu’en anglais).

Bien sûr, elles ne sont pas parfaites, il faudrait protéger les données à insérer ou à modifier par des htmlspecialchars() et addslashes(). Mais pour ça, c’est à vous de jouer, je ne vais pas vous prémacher tout le travail non plus !