Come funziona il caching degli oggetti?

WordPress, per impostazione predefinita, implementa una forma di "Object Caching" ma la sua durata è limitata al caricamento di una singola pagina.

Le opzioni sono un ottimo esempio di questo comportamento. Dai un'occhiata a questa risposta per maggiori informazioni. Ecco un riepilogo:

1. Inizia il caricamento di una pagina
2. Tutte le opzioni vengono caricate con una semplice query SELECT option_name, option_value from $wpdb->options
3. Le richieste successive per quelle opzioni (ad esempio una chiamata a get_option) non interrogano il database perché sono memorizzate tramite l'API di cache di WP.

Le opzioni "vivono" sempre nel database e vi sono sempre memorizzate in modo permanente — questa è la loro fonte "canonica". Detto ciò, le opzioni vengono caricate nella cache degli oggetti, quindi quando richiedi un'opzione c'è il 99% di probabilità che tale richiesta non interroghi mai il database.

I transient sono un po' diversi.

WordPress ti consente di sostituire l'API della cache con un drop-in — un file che viene posizionato direttamente nella tua cartella wp-content. Se crei il tuo drop-in per la cache o usi un plugin esistente come questo, puoi far sì che la cache degli oggetti persista oltre il caricamento di una singola pagina. Quando lo fai, il comportamento dei transient cambia leggermente.

Diamo un'occhiata alla funzione set_transient in wp-includes/option.php.

<?php
/**
 * Imposta/aggiorna il valore di un transient.
 *
 * Non è necessario serializzare i valori. Se il valore deve essere serializzato, verrà
 * serializzato automaticamente prima di essere impostato.
 *
 * @since 2.8.0
 * @package WordPress
 * @subpackage Transient
 *
 * @uses apply_filters() Chiama l'hook 'pre_set_transient_$transient' per consentire la sovrascrittura
 *  del valore del transient da memorizzare.
 * @uses do_action() Chiama gli hook 'set_transient_$transient' e 'setted_transient' in caso di successo.
 *
 * @param string $transient Nome del transient. Non deve essere escapato per SQL.
 * @param mixed $value Valore del transient. Non deve essere escapato per SQL.
 * @param int $expiration Tempo fino alla scadenza in secondi, default 0
 * @return bool False se il valore non è stato impostato, true se è stato impostato.
 */
function set_transient( $transient, $value, $expiration = 0 ) {
    global $_wp_using_ext_object_cache;

    $value = apply_filters( 'pre_set_transient_' . $transient, $value );

    if ( $_wp_using_ext_object_cache ) {
        $result = wp_cache_set( $transient, $value, 'transient', $expiration );
    } else {
        $transient_timeout = '_transient_timeout_' . $transient;
        $transient = '_transient_' . $transient;
        if ( false === get_option( $transient ) ) {
            $autoload = 'yes';
            if ( $expiration ) {
                $autoload = 'no';
                add_option( $transient_timeout, time() + $expiration, '', 'no' );
            }
            $result = add_option( $transient, $value, '', $autoload );
        } else {
            if ( $expiration )
                update_option( $transient_timeout, time() + $expiration );
            $result = update_option( $transient, $value );
        }
    }
    if ( $result ) {
        do_action( 'set_transient_' . $transient );
        do_action( 'setted_transient', $transient );
    }
    return $result;
}

Hmmm $_wp_using_ext_object_cache? Se è true, WordPress utilizza la cache degli oggetti invece del database per memorizzare i transient. Ma come viene impostato su true? È ora di esplorare come WP configura la sua API di cache.

Puoi risalire quasi tutto a wp-load.php o wp-settings.php — entrambi cruciali per il processo di bootstrap di WordPress. Nel nostro caso, ci sono alcune righe rilevanti in wp-settings.php.

// Avvia la cache degli oggetti di WordPress, o una cache esterna se è presente il drop-in.
wp_start_object_cache();

Ricordi quel drop-in di cui parlavamo prima? Diamo un'occhiata a wp_start_object_cache in wp-includes/load.php.

<?php
/**
 * Avvia la cache degli oggetti di WordPress.
 *
 * Se esiste un file object-cache.php nella directory wp-content,
 * lo utilizza come cache esterna degli oggetti.
 *
 * @access private
 * @since 3.0.0
 */
function wp_start_object_cache() {
    global $_wp_using_ext_object_cache, $blog_id;

    $first_init = false;
    if ( ! function_exists( 'wp_cache_init' ) ) {
        if ( file_exists( WP_CONTENT_DIR . '/object-cache.php' ) ) {
            require_once ( WP_CONTENT_DIR . '/object-cache.php' );
            $_wp_using_ext_object_cache = true;
        } else {
            require_once ( ABSPATH . WPINC . '/cache.php' );
            $_wp_using_ext_object_cache = false;
        }
        $first_init = true;
    } else if ( !$_wp_using_ext_object_cache && file_exists( WP_CONTENT_DIR . '/object-cache.php' ) ) {
        // A volte advanced-cache.php può caricare object-cache.php prima che venga caricato qui.
        // Ciò può invalidare il controllo function_exists sopra e portare a un'impostazione errata di $_wp_using_ext_object_cache.
        // Verifica nuovamente se esiste una cache esterna.
        $_wp_using_ext_object_cache = true;
    }

    // Se la cache supporta il reset, resetta invece di inizializzare se già inizializzata.
    // Il reset segnala alla cache che gli ID globali sono cambiati e potrebbe essere necessario aggiornare le chiavi
    // e pulire le cache.
    if ( ! $first_init && function_exists( 'wp_cache_switch_to_blog' ) )
        wp_cache_switch_to_blog( $blog_id );
    else
        wp_cache_init();

    if ( function_exists( 'wp_cache_add_global_groups' ) ) {
        wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'site-transient', 'site-options', 'site-lookup', 'blog-lookup', 'blog-details', 'rss', 'global-posts', 'blog-id-cache' ) );
        wp_cache_add_non_persistent_groups( array( 'comment', 'counts', 'plugins' ) );
    }
}

Le righe rilevanti della funzione (quelle relative a $_wp_using_ext_object_cache che alterano il modo in cui i transient vengono memorizzati).

if ( file_exists( WP_CONTENT_DIR . '/object-cache.php' ) ) {
    require_once ( WP_CONTENT_DIR . '/object-cache.php' );
    $_wp_using_ext_object_cache = true;
} else {
    require_once ( ABSPATH . WPINC . '/cache.php' );
    $_wp_using_ext_object_cache = false;
}

Se object-cache.php esiste nella tua directory dei contenuti, viene incluso e WP assume che stai utilizzando una cache esterna e persistente — imposta $_wp_using_ext_object_cache su true.

Se stai utilizzando una cache esterna degli oggetti, i transient la utilizzeranno. Il che solleva la questione di quando usare le opzioni rispetto ai transient.

Semplice. Se hai bisogno che i dati persistano indefinitamente, usa le opzioni. Vengono "memorizzate nella cache", ma la loro fonte canonica è il database e non scompariranno mai a meno che un utente non lo richieda esplicitamente.

Per i dati che devono essere memorizzati per un periodo di tempo determinato, ma non devono persistere oltre una durata specificata, usa i transient. Internamente, WP cercherà di utilizzare una cache esterna e persistente degli oggetti, se possibile; altrimenti i dati finiranno nella tabella delle opzioni e verranno raccolti come garbage tramite il pseudo-cron di WordPress quando scadranno.

Alcune altre considerazioni/domande:

1. Va bene fare molte chiamate a get_option? Probabilmente sì. Hanno il sovraccarico della chiamata a una funzione, ma è improbabile che interroghino il database. Il carico sul database è spesso una preoccupazione maggiore nella scalabilità delle applicazioni web rispetto al lavoro che il tuo linguaggio di programmazione fa per generare una pagina.
2. Come faccio a sapere se usare i transient o l'API della Cache? Se ti aspetti che i dati persistano per un periodo determinato, usa l'API dei transient. Se non importa che i dati persistano (ad esempio, non ci vuole molto tempo per calcolare/recuperare i dati, ma non dovrebbe accadere più di una volta per caricamento della pagina), usa l'API della cache.
3. Vengono davvero memorizzate tutte le opzioni in cache ad ogni caricamento di pagina? Non necessariamente. Se chiami add_option con il suo ultimo argomento opzionale impostato su no, non vengono caricate automaticamente. Detto ciò, una volta che le recuperi una volta, vanno nella cache e le chiamate successive non interrogano il database.