Bonjour, pour optimiser les performances de notre Prestashop 1.6.1.4 il nous est conseillé d'utiliser le cache memcache (ou autre) par contre lorsqu'on l'active les résultats sont inutilisables en production. Après analyse du code, il s'avère que les requêtes sql sont cachées par la classe DB, donc la fonction executeS est utilisée principalement avec le paramètre par défaut $use_cache = true. Un exemple concret serait celui de la création d'une adresse par un client : La fonction getAddresses() dans Customer.php enregistre le résultat de la requête dans une clé de cache du type 'Customer::getAddresses1234-2-0'
public function getAddresses($id_lang)
{
$share_order = (bool)Context::getContext()->shop->getGroup()->share_order;
$cache_id = 'Customer::getAddresses'.(int)$this->id.'-'.(int)$id_lang.'-'.$share_order;
if (!Cache::isStored($cache_id)) {
$sql = 'SELECT DISTINCT a.*, cl.`name` AS country, s.name AS state, s.iso_code AS state_iso
FROM `'._DB_PREFIX_.'address` a
LEFT JOIN `'._DB_PREFIX_.'country` c ON (a.`id_country` = c.`id_country`)
LEFT JOIN `'._DB_PREFIX_.'country_lang` cl ON (c.`id_country` = cl.`id_country`)
LEFT JOIN `'._DB_PREFIX_.'state` s ON (s.`id_state` = a.`id_state`)
'.($share_order ? '' : Shop::addSqlAssociation('country', 'c')).'
WHERE `id_lang` = '.(int)$id_lang.' AND `id_customer` = '.(int)$this->id.' AND a.`deleted` = 0';
$result = Db::getInstance(_PS_USE_SQL_SLAVE_)->executeS($sql);
Cache::store($cache_id, $result);
return $result;
}
return Cache::retrieve($cache_id);
}
par contre cette clé ne me semble pas invalidée lorsque le client ajoute ou supprime une adresse... ensuite, la requête $sql ci dessus en elle même est cachée par la fonction executeS($sql) dans Db.php
public function executeS($sql, $array = true, $use_cache = true)
{
if ($use_cache && $this->is_cache_enabled && $array) {
$this->last_query_hash = Tools::encryptIV($sql);
if (($result = Cache::getInstance()->get($this->last_query_hash)) !== false) {
$this->last_cached = true;
return $result;
}
}
...
$this->last_cached = false;
if ($use_cache && $this->is_cache_enabled && $array) {
Cache::getInstance()->setQuery($sql, $result);
}
return $result;
}
la clé de cache étant l'encryptage de la requête qu'il voit passer, une requête du type :
SELECT DISTINCT a.*, cl.`name` AS country, s.name AS state, s.iso_code AS state_iso
FROM `ps_address` a
LEFT JOIN `ps_country` c ON (a.`id_country` = c.`id_country`)
LEFT JOIN `ps_country_lang` cl ON (c.`id_country` = cl.`id_country`)
LEFT JOIN `ps_state` s ON (s.`id_state` = a.`id_state`)
INNER JOIN ps_country_shop country_shop
ON (country_shop.id_country = c.id_country AND country_shop.id_shop = 1)
WHERE `id_lang` = 1 AND `id_customer` = 1 AND a.`deleted` = 0
tant que cette clé précise n'est pas invalidée ou que tant que la requête est identique (ce qui est la cas), le résultat retourné est le résultat qui a été mis en cache précédemment... Soit, lorsqu'un client ajoute une adresse il ne peut pas la voir apparaître dans la liste de ses adresses... et ce comportement peut se constater sur une grande partie de ces requêtes dont le cache n'est pas invalidé correctement (la requête dans Product.php getImages() par exemple etc.) Est-ce que quelqu'un utilise le cache sans rencontrer ces problèmes ? Est-ce que vous avez une astuce pour les régler autre que simplement s'asseoir sur cette fonctionnalité pourtant prometteuse ? Je vous remercie d'avance