SQL_Intervals

SQL_Intervals est une classe PHP qui permet de gérer, comme son nom l’indique une table SQL ayant une structure intervallaire. Vous pouvez la télécharger et l’utiliser, tout en respectant sa licence.

Une nouvelle gestion de la hiérarchie

La gestion des hiérarchies est dans tous les cas une problématique importante. Qu’elle soit gérée dans une base de données ou dans des fichiers statiques, cette hiérarchie doit être bien structurée pour pouvoir être (ré)utilisée convenablement. La gestion intervallaire sert à ça ! Elle est une des solutions de hiérarchisation dans la base de données.

Une gestion plus complexe de la base de données

L’utilisation d’une telle base demande néanmoins plus de rigueur car la structure ne doit pas être corrompue. C’est pourquoi, l’utilisation d’une classe spécifique a ceci est une solution qui permet de ne pas risquer d’altèrer l’intégrité de notre table, et par extension de notre hiérarchie.

La librairie

Une gestion des requêtes séparée

Il faut savoir que la plupart des requêtes SQL changent en fonction de la base de données : la structure est presque la même mais il y a une syntaxe à respecter pour certains moteurs de bases de données qui lui sont spéciales (je pense à MySQL et les « ` » par exemple). De ce fait, il faut savoir gérer ces différentes options si l’on souhaite utiliser cette librairie dans divers environnements de base de données.

Pour palier à ce problème, la librairie SQL_Intervals utilise donc d’autres librairies « filles ». Elle se nomment SQL_Intervals_xxx, où xxx est le code du moteur de base de données. Les bases de données actuellement supportées par cette librairies sont:

  1. MySQL (mysql)
  2. PostgreSQL (pgsql)
  3. SQLite 3 (sqlite)

Ses fonctions

  • Ajouter des éléments à la racine ou dans un élément père.
  • Supprimer des éléments, qu’ils soient des nœuds ou des feuilles[1].
  • Déplacer des éléments dans la hiérarchie de manière optimisée. C’est-à-dire que pour déplacer, la classe ne supprime pas l’élément puis le créé, elle modifie uniquement les éléments entre la position actuelle et la future position de l’élément.

[1] De manière général, un nœud est un élément ayant d’autres éléments fils, une feuille n’a pas d’élément fils.

Télécharger

Vous pouvez télécharger un fichier compressé des deux classes principales et de ses classes « filles », qui dépendent de la base de données:

Vous pouvez aussi explorer les fichiers dans le dépôt de sources se trouvant à cette adresse.

Exemple

Soit un table « nom_de_ma_table » comme celle-ci:

+----+------+----+--------+--------+
| id | from | to | other1 | other2 |
+----+------+----+--------+--------+
| 1  | 0    | 1  | ALL    | ALL    |
+----+------+----+--------+--------+
<?php 
require_once './Classes/SQL_Intervals.php'; 
require_once './Classes/SQL_Intervals_mysql.php'; 
 
define('TABLE', 'nom_de_ma_table'); 
 
// Création de l'accès à la base de données 
$sql = new PDO('mysql:host=localhost;dbname=tests', 'root', ''); 
 
// Instanciation de la classe de gestion d'une table avec un système 
// de gestion SQL par intervalles. 
$intervalles = new SQL_Intervals($sql); 
 
// Création d'éléments 
$first = $intervalles->add(TABLE, 1, array('other1' => 'first'));
$second = $intervalles->add(TABLE, 1, array('other1' => 'first2', 'other2' => 'value2'));
 
// Des enfants
$intervalles->add(TABLE, $second, array('other1' => 'child');
$last = $intervalles->add(TABLE, $second, array('other2' => 'child');

A ce moment, nous avons une table telle que:

+----+------+----+--------+--------+
| id | from | to | other1 | other2 |
+----+------+----+--------+--------+
| 1  | 0    | 9  | ALL    | ALL    |
| 2  | 1    | 2  | first  | NULL   |
| 3  | 3    | 8  | first2 | value2 |
| 4  | 4    | 5  | child  | NULL   |
| 5  | 6    | 7  | NULL   | child  |
+----+------+----+--------+--------+

Ce qui nous donne un arbre de hiérarchie tel que:

     1
    / \
   2   3
      / \
     4   5
// Déplacer
$intervalles->move(TABLE, $second, $first);
$intervalles->move(TABLE, $last, 1); // 1 = racine

Ce qui fait un arbre comme ceci à la première opération:

     1
    /
   2
   |
   3
  / \
 4   5

Puis comme ceci à la deuxième:

     1
    / \
   2   5
   |
   3
   |
   4

Et une table comme ceci:

+----+------+----+--------+--------+
| id | from | to | other1 | other2 |
+----+------+----+--------+--------+
| 1  | 0    | 9  | ALL    | ALL    |
| 2  | 1    | 6  | first  | NULL   |
| 3  | 2    | 5  | first2 | value2 |
| 4  | 3    | 4  | child  | NULL   |
| 5  | 7    | 8  | NULL   | child  |
+----+------+----+--------+--------+

Pour supprimer un élément, il vous suffit de faire:

$intervalles->remove(TABLE, $second);

Pour avoir un arbre comme ceci:

     1
    / \
   2   5

Laisser un commentaire