Description

public function Yac::dump(int $limit = 100, int $offset = 0): array

Vide les métadonnées des entrées actuellement stockées dans le cache. Les valeurs elles-mêmes ne sont pas retournées.

Liste de paramètres

limit

Nombre maximum d'entrées à retourner.

Passer -1 comme limit vide toutes les entrées actuellement présentes dans le cache. Il est à noter que construire la liste complète peut utiliser une quantité considérable de mémoire pour un grand cache ; quand la mémoire est un critère, il vaut mieux paginer les entrées avec limit et offset.

offset

Nombre d'entrées à sauter avant de collecter. Ce paramètre est disponible à partir de PECL yac 2.4.0 ; les versions antérieures commencent toujours depuis la première entrée. Combiné avec limit, il peut être utilisé pour paginer un cache contenant plus d'entrées qu'un seul appel ne peut en retourner.

Valeurs de retour

Un array avec un élément par entrée vidée. Chaque élément est lui-même un tableau décrivant l'entrée :

index: L'index de slot de l'entrée dans la table de hachage.
hash: Le hachage 64 bits de la clé, utilisé pour le sondage de slots.
crc: La somme de contrôle CRC32 de la valeur stockée, utilisée pour détecter les lectures incomplètes. 0 pour les entrées intégrées, qui n'ont pas de bloc de valeur.
ttl: L'horodatage d'expiration (heure Unix). 0 signifie que l'entrée n'expire jamais dans le temps. Il est à noter que Yac::delete() marque seulement une entrée comme expirée, donc les entrées supprimées peuvent encore apparaître dans le vidage ; un ttl non nul dans le passé indique une entrée expirée ou supprimée.
k_len: La longueur de la clé, en octets.
v_len: La longueur de la valeur, en octets. Pour les entrées compressées, c'est la longueur de la valeur originale avant compression (à partir de yac 2.4.0 ; les versions antérieures rapportaient la longueur stockée, compressée).
c_len: Présent uniquement pour les entrées compressées (à partir de yac 2.4.0) : la longueur du contenu compressé réellement stocké en mémoire partagée, en octets. Comparer c_len avec v_len montre combien la compression économise par entrée.
size: La taille allouée du bloc de valeur en mémoire partagée, en octets. 0 pour les entrées intégrées.
atime: Le dernier temps d'accès (heure Unix), mis à jour à chaque Yac::get() réussi. Quand le cache est plein, l'entrée avec l'atime le plus ancien parmi les slots candidats est expulsée en premier (à partir de yac 2.4.0).
hits: Un compteur de succès par entrée, incrémenté à chaque Yac::get() réussi et remis à zéro quand l'entrée est écrasée par un nouveau Yac::set() ou Yac::add() (à partir de yac 2.4.0).
embedded: Si la valeur est stockée directement à l'intérieur du slot plutôt que dans un bloc de valeur séparé (à partir de yac 2.4.0). Les petites valeurs — NULL, booléens, petits entiers, chaînes jusqu'à 7 octets et tableaux vides — sont intégrées de cette façon et n'allouent aucune mémoire de valeur ; pour elles, crc et size sont rapportés à 0.
key: La clé de cache, sans aucun préfixe d'instance.

Exemples

Exemple #1 Exemple avec Yac::dump()

<?php
$yac = new Yac();
$yac->set("foo", "bar");
$yac->set("baz", "qux");

print_r($yac->dump());
?>

Résultat de l'exemple ci-dessus est similaire à :

Array
(
    [0] => Array
        (
            [index] => 12345
            [hash] => 14463105906481965911
            [crc] => 0
            [ttl] => 0
            [k_len] => 3
            [v_len] => 3
            [size] => 0
            [atime] => 1725955200
            [hits] => 0
            [embedded] => 1
            [key] => foo
        )

    [1] => Array
        (
            [index] => 12987
            [hash] => 15132029420525657053
            [crc] => 0
            [ttl] => 0
            [k_len] => 3
            [v_len] => 3
            [size] => 0
            [atime] => 1725955200
            [hits] => 0
            [embedded] => 1
            [key] => baz
        )

)

Les entrées sont listées dans l'ordre des slots, pas dans l'ordre où elles ont été stockées. Les entrées intégrées (petits scalaires gardés à l'intérieur du slot lui-même) ont crc et size à zéro ; les entrées stockées dans un bloc de valeur séparé portent leur somme de contrôle et taille de bloc, et les entrées compressées portent additionnellement c_len.

Exemple #2 Pagination d'un grand cache

limit limite le nombre d'entrées qu'un seul appel retourne, et offset en saute autant avant de collecter, donc les deux peuvent être combinés pour paginer un cache contenant plus d'entrées qu'un appel peut en retourner.

<?php
$yac = new Yac();

// remplir le cache avec 250 entrées
for ($i = 0; $i < 250; $i++) {
    $yac->set("key$i", $i);
}

$page_size = 100;
$page_num  = 2;

// sauter les 100 premières entrées et retourner les 100 suivantes (page 2)
$page = $yac->dump($page_size, $page_size * ($page_num - 1));

var_dump(count($page));
?>

Résultat de l'exemple ci-dessus est similaire à :

int(100)

Moins d'entrées que demandé sont retournées quand le cache en contient moins que la page demandée ne couvre, et un tableau vide est retourné quand l'offset pointe au-delà du dernier slot occupé.

Voir aussi

Yac::info() - État du cache