New file |
0,0 → 1,606 |
<?php |
class CacheSqlite { |
/** |
* Available options |
* |
* =====> (string) cache_db_complete_path : |
* - the complete path (filename included) of the SQLITE database |
* |
* ====> (int) automatic_vacuum_factor : |
* - Disable / Tune the automatic vacuum process |
* - The automatic vacuum process defragment the database file (and make it smaller) |
* when a clean() or delete() is called |
* 0 => no automatic vacuum |
* 1 => systematic vacuum (when delete() or clean() methods are called) |
* x (integer) > 1 => automatic vacuum randomly 1 times on x clean() or delete() |
* |
* @var array Available options |
*/ |
protected $options = array( |
'stockage_chemin' => null, |
'defragmentation_auto' => 10 |
); |
|
/** |
* DB ressource |
* |
* @var mixed $db |
*/ |
private $bdd = null; |
|
/** |
* Boolean to store if the structure has benn checked or not |
* |
* @var boolean $structure_ok |
*/ |
private $structure_ok = false; |
|
private $Cache = null; |
|
/** |
* Constructor |
* |
* @param array $options Associative array of options |
* @throws Zend_cache_Exception |
* @return void |
*/ |
public function __construct(array $options = array(), Cache $cache) { |
$this->Cache = $cache; |
if (extension_loaded('sqlite')) { |
$this->setOptions($options); |
} else { |
$e = "Impossible d'utiliser le cache SQLITE car l'extenssion 'sqlite' n'est pas chargée dans l'environnement PHP courrant."; |
trigger_error($e, E_USER_ERROR); |
} |
} |
|
/** |
* Destructor |
* |
* @return void |
*/ |
public function __destruct() { |
@sqlite_close($this->getConnexion()); |
} |
|
private function setOptions($options) { |
while (list($nom, $valeur) = each($options)) { |
if (!is_string($nom)) { |
trigger_error("Nom d'option incorecte : $nom", E_USER_WARNING); |
} |
$nom = strtolower($nom); |
if (array_key_exists($nom, $this->options)) { |
$this->options[$nom] = $valeur; |
} |
} |
} |
|
public function setEmplacement($emplacement) { |
if (extension_loaded('sqlite')) { |
$this->options['stockage_chemin'] = $emplacement; |
} else { |
trigger_error("Impossible d'utiliser le mode de sotckage SQLite car l'extenssion 'sqlite' n'est pas chargé dans ". |
"l'environnement PHP courrant.", E_USER_ERROR); |
} |
} |
|
/** |
* Test if a cache is available for the given id and (if yes) return it (false else) |
* |
* @param string $id Cache id |
* @param boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested |
* @return string|false Cached datas |
*/ |
public function charger($id, $ne_pas_tester_validiter_du_cache = false) { |
$this->verifierEtCreerStructureBdd(); |
$requete = "SELECT content FROM cache WHERE id = '$id'". |
(($ne_pas_tester_validiter_du_cache) ? '' : ' AND (expire = 0 OR expire > '.time().')'); |
$resultat = $this->requeter($requete); |
$ligne = @sqlite_fetch_array($resultat); |
return ($ligne) ? $ligne['content'] : false; |
} |
|
/** |
* Test if a cache is available or not (for the given id) |
* |
* @param string $id Cache id |
* @return mixed|false (a cache is not available) or "last modified" timestamp (int) of the available cache record |
*/ |
public function tester($id) { |
$this->verifierEtCreerStructureBdd(); |
$requete = "SELECT lastModified FROM cache WHERE id = '$id' AND (expire = 0 OR expire > ".time().')'; |
$resultat = $this->requeter($requete); |
$ligne = @sqlite_fetch_array($resultat); |
return ($ligne) ? ((int) $ligne['lastModified']) : false; |
} |
|
/** |
* Save some string datas into a cache record |
* |
* Note : $data is always "string" (serialization is done by the |
* core not by the backend) |
* |
* @param string $data Datas to cache |
* @param string $id Cache id |
* @param array $tags Array of strings, the cache record will be tagged by each string entry |
* @param int $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime) |
* @throws Zend_Cache_Exception |
* @return boolean True if no problem |
*/ |
public function sauver($donnees, $id, $tags = array(), $duree_vie_specifique = false) { |
$this->verifierEtCreerStructureBdd(); |
$donnees = @sqlite_escape_string($donnees); |
$timestamp_courrant = time(); |
$expiration = $this->Cache->getTimestampExpiration($duree_vie_specifique); |
|
$this->requeter("DELETE FROM cache WHERE id = '$id'"); |
$sql = "INSERT INTO cache (id, content, lastModified, expire) VALUES ('$id', '$donnees', $timestamp_courrant, $expiration)"; |
$resultat = $this->requeter($sql); |
if (!$resultat) { |
// TODO : ajouter un log sauver() : impossible de stocker le cache d'id '$id' |
Debug::printr("sauver() : impossible de stocker le cache d'id '$id'"); |
$resultat = false; |
} else { |
$resultat = true; |
foreach ($tags as $tag) { |
$resultat = $this->enregisterTag($id, $tag) && $resultat; |
} |
} |
return $resultat; |
} |
|
/** |
* Remove a cache record |
* |
* @param string $id Cache id |
* @return boolean True if no problem |
*/ |
public function supprimer($id) { |
$this->verifierEtCreerStructureBdd(); |
$resultat = $this->requeter("SELECT COUNT(*) AS nbr FROM cache WHERE id = '$id'"); |
$resultat_nbre = @sqlite_fetch_single($resultat); |
$suppression_cache = $this->requeter("DELETE FROM cache WHERE id = '$id'"); |
$suppression_tags = $this->requeter("DELETE FROM tag WHERE id = '$id'"); |
$this->defragmenterAutomatiquement(); |
return ($resultat_nbre && $suppression_cache && $suppression_tags); |
} |
|
/** |
* Clean some cache records |
* |
* Available modes are : |
* Zend_Cache::CLEANING_MODE_ALL (default) => remove all cache entries ($tags is not used) |
* Zend_Cache::CLEANING_MODE_OLD => remove too old cache entries ($tags is not used) |
* Zend_Cache::CLEANING_MODE_MATCHING_TAG => remove cache entries matching all given tags |
* ($tags can be an array of strings or a single string) |
* Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags} |
* ($tags can be an array of strings or a single string) |
* Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags |
* ($tags can be an array of strings or a single string) |
* |
* @param string $mode Clean mode |
* @param array $tags Array of tags |
* @return boolean True if no problem |
*/ |
public function nettoyer($mode = Cache::NETTOYAGE_MODE_TOUS, $tags = array()) { |
$this->verifierEtCreerStructureBdd(); |
$retour = $this->nettoyerSqlite($mode, $tags); |
$this->defragmenterAutomatiquement(); |
return $retour; |
} |
|
/** |
* Return an array of stored cache ids |
* |
* @return array array of stored cache ids (string) |
*/ |
public function getIds() { |
$this->verifierEtCreerStructureBdd(); |
$resultat = $this->requeter('SELECT id FROM cache WHERE (expire = 0 OR expire > '.time().')'); |
$retour = array(); |
while ($id = @sqlite_fetch_single($resultat)) { |
$retour[] = $id; |
} |
return $retour; |
} |
|
/** |
* Return an array of stored tags |
* |
* @return array array of stored tags (string) |
*/ |
public function getTags() { |
$this->verifierEtCreerStructureBdd(); |
$resultat = $this->requeter('SELECT DISTINCT(name) AS name FROM tag'); |
$retour = array(); |
while ($id = @sqlite_fetch_single($resultat)) { |
$retour[] = $id; |
} |
return $retour; |
} |
|
/** |
* Return an array of stored cache ids which match given tags |
* |
* In case of multiple tags, a logical AND is made between tags |
* |
* @param array $tags array of tags |
* @return array array of matching cache ids (string) |
*/ |
public function getIdsAvecLesTags($tags = array()) { |
$this->verifierEtCreerStructureBdd(); |
$premier = true; |
$ids = array(); |
foreach ($tags as $tag) { |
$resultat = $this->requeter("SELECT DISTINCT(id) AS id FROM tag WHERE name='$tag'"); |
if ($resultat) { |
$lignes = @sqlite_fetch_all($resultat, SQLITE_ASSOC); |
$ids_tmp = array(); |
foreach ($lignes as $ligne) { |
$ids_tmp[] = $ligne['id']; |
} |
if ($premier) { |
$ids = $ids_tmp; |
$premier = false; |
} else { |
$ids = array_intersect($ids, $ids_tmp); |
} |
} |
} |
|
$retour = array(); |
if (count($ids) > 0) { |
foreach ($ids as $id) { |
$retour[] = $id; |
} |
} |
return $retour; |
} |
|
/** |
* Return an array of stored cache ids which don't match given tags |
* |
* In case of multiple tags, a logical OR is made between tags |
* |
* @param array $tags array of tags |
* @return array array of not matching cache ids (string) |
*/ |
public function getIdsSansLesTags($tags = array()) { |
$this->verifierEtCreerStructureBdd(); |
$resultat = $this->requeter('SELECT id FROM cache'); |
$lignes = @sqlite_fetch_all($resultat, SQLITE_ASSOC); |
$retour = array(); |
foreach ($lignes as $ligne) { |
$id = $ligne['id']; |
$correspondance = false; |
foreach ($tags as $tag) { |
$resultat = $this->requeter("SELECT COUNT(*) AS nbr FROM tag WHERE name = '$tag' AND id = '$id'"); |
if ($resultat) { |
$nbre = (int) @sqlite_fetch_single($resultat); |
if ($nbre > 0) { |
$correspondance = true; |
} |
} |
} |
if (!$correspondance) { |
$retour[] = $id; |
} |
} |
return $retour; |
} |
|
/** |
* Return an array of stored cache ids which match any given tags |
* |
* In case of multiple tags, a logical AND is made between tags |
* |
* @param array $tags array of tags |
* @return array array of any matching cache ids (string) |
*/ |
public function getIdsAvecUnTag($tags = array()) { |
$this->verifierEtCreerStructureBdd(); |
$premier = true; |
$ids = array(); |
foreach ($tags as $tag) { |
$resultat = $this->requeter("SELECT DISTINCT(id) AS id FROM tag WHERE name = '$tag'"); |
if ($resultat) { |
$lignes = @sqlite_fetch_all($resultat, SQLITE_ASSOC); |
$ids_tmp = array(); |
foreach ($lignes as $ligne) { |
$ids_tmp[] = $ligne['id']; |
} |
if ($premier) { |
$ids = $ids_tmp; |
$premier = false; |
} else { |
$ids = array_merge($ids, $ids_tmp); |
} |
} |
} |
|
$retour = array(); |
if (count($ids) > 0) { |
foreach ($ids as $id) { |
$retour[] = $id; |
} |
} |
return $retour; |
} |
|
/** |
* Return the filling percentage of the backend storage |
* |
* @throws Zend_Cache_Exception |
* @return int integer between 0 and 100 |
*/ |
public function getPourcentageRemplissage() { |
$dossier = dirname($this->options['stockage_chemin']); |
$libre = disk_free_space($dossier); |
$total = disk_total_space($dossier); |
|
$pourcentage = 0; |
if ($total == 0) { |
trigger_error("Impossible d'utiliser la fonction disk_total_space", E_USER_WARNING); |
} else { |
$pourcentage = ($libre >= $total) ? 100 : ((int) (100. * ($total - $libre) / $total)); |
} |
return $pourcentage; |
} |
|
/** |
* Return an array of metadatas for the given cache id |
* |
* The array must include these keys : |
* - expire : the expire timestamp |
* - tags : a string array of tags |
* - mtime : timestamp of last modification time |
* |
* @param string $id cache id |
* @return array array of metadatas (false if the cache id is not found) |
*/ |
public function getMetadonnees($id) { |
$this->verifierEtCreerStructureBdd(); |
$tags = array(); |
$resultat = $this->requeter("SELECT name FROM tag WHERE id = '$id'"); |
if ($resultat) { |
$lignes = @sqlite_fetch_all($resultat, SQLITE_ASSOC); |
foreach ($lignes as $ligne) { |
$tags[] = $ligne['name']; |
} |
} |
$resultat = $this->requeter("SELECT lastModified, expire FROM cache WHERE id = '$id'"); |
if ($resultat) { |
$ligne = @sqlite_fetch_array($resultat, SQLITE_ASSOC); |
$resultat = array( |
'tags' => $tags, |
'mtime' => $ligne['lastModified'], |
'expiration' => $ligne['expire']); |
} else { |
$resultat = false; |
} |
return $resultat; |
} |
|
/** |
* Give (if possible) an extra lifetime to the given cache id |
* |
* @param string $id cache id |
* @param int $extraLifetime |
* @return boolean true if ok |
*/ |
public function ajouterSupplementDureeDeVie($id, $supplement_duree_de_vie) { |
$this->verifierEtCreerStructureBdd(); |
$augmentation = false; |
$requete = "SELECT expire FROM cache WHERE id = '$id' AND (expire = 0 OR expire > ".time().')'; |
$resultat = $this->requeter($requete); |
if ($resultat) { |
$expiration = @sqlite_fetch_single($resultat); |
$nouvelle_expiration = $expiration + $supplement_duree_de_vie; |
$resultat = $this->requeter('UPDATE cache SET lastModified = '.time().", expire = $nouvelle_expiration WHERE id = '$id'"); |
$augmentation = ($resultat) ? true : false; |
} |
return $augmentation; |
} |
|
/** |
* Return the connection resource |
* |
* If we are not connected, the connection is made |
* |
* @throws Zend_Cache_Exception |
* @return resource Connection resource |
*/ |
private function getConnexion() { |
if (!is_resource($this->bdd)) { |
if ($this->options['stockage_chemin'] === null) { |
$e = "L'emplacement du chemin vers le fichier de la base de données SQLite n'a pas été défini"; |
trigger_error($e, E_USER_ERROR); |
} else { |
$this->bdd = sqlite_open($this->options['stockage_chemin']); |
if (!(is_resource($this->bdd))) { |
$e = "Impossible d'ouvrir le fichier '".$this->options['stockage_chemin']."' de la base de données SQLite."; |
trigger_error($e, E_USER_ERROR); |
$this->bdd = null; |
} |
} |
} |
return $this->bdd; |
} |
|
/** |
* Execute une requête SQL sans afficher de messages d'erreur. |
* |
* @param string $requete requête SQL |
* @return mixed|false resultats de la requête |
*/ |
private function requeter($requete) { |
$bdd = $this->getConnexion(); |
//Debug::printr($requete); |
$resultat = (is_resource($bdd)) ? @sqlite_query($bdd, $requete, SQLITE_ASSOC, $e_sqlite) : false; |
if (is_resource($bdd) && ! $resultat) { |
Debug::printr("Erreur SQLITE :\n$e_sqlite\nPour la requête :\n$requete\nRessource : $bdd"); |
} |
return $resultat; |
} |
|
/** |
* Deal with the automatic vacuum process |
* |
* @return void |
*/ |
private function defragmenterAutomatiquement() { |
if ($this->options['defragmentation_auto'] > 0) { |
$rand = rand(1, $this->options['defragmentation_auto']); |
if ($rand == 1) { |
$this->requeter('VACUUM'); |
@sqlite_close($this->getConnexion()); |
} |
} |
} |
|
/** |
* Register a cache id with the given tag |
* |
* @param string $id Cache id |
* @param string $tag Tag |
* @return boolean True if no problem |
*/ |
private function enregisterTag($id, $tag) { |
$requete_suppression = "DELETE FROM tag WHERE name = '$tag' AND id = '$id'"; |
$resultat = $this->requeter($requete_suppression); |
$requete_insertion = "INSERT INTO tag(name,id) VALUES ('$tag','$id')"; |
$resultat = $this->requeter($requete_insertion); |
if (!$resultat) { |
// TODO : ajouter un log -> impossible d'enregistrer le tag=$tag pour le cache id=$id"); |
Debug::printr("Impossible d'enregistrer le tag=$tag pour le cache id=$id"); |
} |
return ($resultat) ? true : false; |
} |
|
/** |
* Build the database structure |
* |
* @return false |
*/ |
private function creerStructure() { |
Debug::printr("création de la str"); |
$this->requeter('DROP INDEX IF EXISTS tag_id_index'); |
$this->requeter('DROP INDEX IF EXISTS tag_name_index'); |
$this->requeter('DROP INDEX IF EXISTS cache_id_expire_index'); |
$this->requeter('DROP TABLE IF EXISTS version'); |
$this->requeter('DROP TABLE IF EXISTS cache'); |
$this->requeter('DROP TABLE IF EXISTS tag'); |
$this->requeter('CREATE TABLE version (num INTEGER PRIMARY KEY)'); |
$this->requeter('CREATE TABLE cache(id TEXT PRIMARY KEY, content BLOB, lastModified INTEGER, expire INTEGER)'); |
$this->requeter('CREATE TABLE tag (name TEXT, id TEXT)'); |
$this->requeter('CREATE INDEX tag_id_index ON tag(id)'); |
$this->requeter('CREATE INDEX tag_name_index ON tag(name)'); |
$this->requeter('CREATE INDEX cache_id_expire_index ON cache(id, expire)'); |
$this->requeter('INSERT INTO version (num) VALUES (1)'); |
} |
|
/** |
* Check if the database structure is ok (with the good version) |
* |
* @return boolean True if ok |
*/ |
private function verifierBddStructureVersion() { |
$version_ok = false; |
$resultat = $this->requeter('SELECT num FROM version'); |
if ($resultat) { |
$ligne = @sqlite_fetch_array($resultat); |
if ($ligne) { |
if (((int) $ligne['num']) == 1) { |
$version_ok = true; |
} else { |
// TODO : ajouter un log CacheSqlite::verifierBddStructureVersion() : vielle version de la structure de la base de données de cache détectée => le cache est entrain d'être supprimé |
} |
} |
} |
return $version_ok; |
} |
|
/** |
* Clean some cache records |
* |
* Available modes are : |
* Zend_Cache::CLEANING_MODE_ALL (default) => remove all cache entries ($tags is not used) |
* Zend_Cache::CLEANING_MODE_OLD => remove too old cache entries ($tags is not used) |
* Zend_Cache::CLEANING_MODE_MATCHING_TAG => remove cache entries matching all given tags |
* ($tags can be an array of strings or a single string) |
* Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags} |
* ($tags can be an array of strings or a single string) |
* Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags |
* ($tags can be an array of strings or a single string) |
* |
* @param string $mode Clean mode |
* @param array $tags Array of tags |
* @return boolean True if no problem |
*/ |
private function nettoyerSqlite($mode = Cache::NETTOYAGE_MODE_TOUS, $tags = array()) { |
$nettoyage_ok = false; |
switch ($mode) { |
case Cache::NETTOYAGE_MODE_TOUS: |
$suppression_cache = $this->requeter('DELETE FROM cache'); |
$suppression_tag = $this->requeter('DELETE FROM tag'); |
$nettoyage_ok = $suppression_cache && $suppression_tag; |
break; |
case Cache::NETTOYAGE_MODE_EXPIRATION: |
$mktime = time(); |
$suppression_tag = $this->requeter("DELETE FROM tag WHERE id IN (SELECT id FROM cache WHERE expire > 0 AND expire <= $mktime)"); |
$suppression_cache = $this->requeter("DELETE FROM cache WHERE expire > 0 AND expire <= $mktime"); |
return $suppression_tag && $suppression_cache; |
break; |
case Cache::NETTOYAGE_MODE_AVEC_LES_TAGS: |
$ids = $this->getIdsAvecLesTags($tags); |
$resultat = true; |
foreach ($ids as $id) { |
$resultat = $this->supprimer($id) && $resultat; |
} |
return $resultat; |
break; |
case Cache::NETTOYAGE_MODE_SANS_LES_TAGS: |
$ids = $this->getIdsSansLesTags($tags); |
$resultat = true; |
foreach ($ids as $id) { |
$resultat = $this->supprimer($id) && $resultat; |
} |
return $resultat; |
break; |
case Cache::NETTOYAGE_MODE_AVEC_UN_TAG: |
$ids = $this->getIdsAvecUnTag($tags); |
$resultat = true; |
foreach ($ids as $id) { |
$resultat = $this->supprimer($id) && $resultat; |
} |
return $resultat; |
break; |
default: |
break; |
} |
return $nettoyage_ok; |
} |
|
/** |
* Check if the database structure is ok (with the good version), if no : build it |
* |
* @throws Zend_Cache_Exception |
* @return boolean True if ok |
*/ |
private function verifierEtCreerStructureBdd() { |
if (! $this->structure_ok) { |
if (! $this->verifierBddStructureVersion()) { |
$this->creerStructure(); |
if (! $this->verifierBddStructureVersion()) { |
$e = "Impossible de construire la base de données de cache dans ".$this->options['stockage_chemin']; |
trigger_error($e, E_USER_WARNING); |
$this->structure_ok = false; |
} |
} |
$this->structure_ok = true; |
} |
return $this->structure_ok; |
} |
|
} |
?> |