class fastcache in Drupal driver for SQL Server and SQL Azure 7.3

Static caching layer.

Database layer for SQL Server is very Regex intensive. Cannot use a regular cache backend because the enormous number of cache_get and cache_set calls end up crashing memcache or wincache! Here everything is statically managed and sent to a real cache backend once the request is over.

Hierarchy

• class \fastcache

5 string references to 'fastcache'

fastcache::cache_load_ensure in sqlsrv/fastcache.inc

Ensure cache binary is statically loaded.

fastcache::cache_set in sqlsrv/fastcache.inc

cache_set wrapper.

fastcache::Enabled in sqlsrv/fastcache.inc

Tell if cache persistence is enabled. If not, this cache will behave as DRUPAL_STATIC until the end of request.

fastcache::fastcache_persist in sqlsrv/fastcache.inc

Called on shutdown, persists the cache if necessary.

fastcache::_fastcache_persist in sqlsrv/fastcache.inc

Persist the binaries.

File

sqlsrv/fastcache.inc, line 23

class fastcache {

  // @var fastcacheitem[]  $fastcacheitems
  private static $fastcacheitems = array();

  // @var bool $enabled
  private static $enabled = NULL;

  // @var bool $shutdown_registered
  private static $shutdown_registered = FALSE;

  /**
   * Test info is loaded at database bootstrap phase
   * but this cache can be used earlier. Make sure
   * we have a valid test prefix before any operation on
   * the cache is performed.
   *
   * @var string
   */
  private static $test_run_id;

  /**
   * Add test prefix to current binary key, and account for atomic
   * items where $bin = NULL;
   *
   * @param string $prefix
   */
  private static function FixKeyAndBin(&$cid, &$bin) {

    // We always need a binary, if non is specified, this item
    // should be treated as having it's own binary.
    if (empty($bin)) {
      $bin = $cid;
    }

    // Try with the "official" test_run_id first.
    if (isset($GLOBALS['drupal_test_info']['test_run_id'])) {
      $bin = $GLOBALS['drupal_test_info']['test_run_id'] . $bin;
      return;
    }

    // Only do this once per request, if the this is the testing system
    // then $GLOBALS['drupal_test_info']['test_run_id'] will be set upon
    // test context switching.
    if (!isset(static::$test_run_id)) {
      if ($test_prefix = drupal_valid_test_ua()) {

        // Keep a local copy of the current test_prefix.
        static::$test_run_id = $test_prefix;
      }
      else {
        static::$test_run_id = '';
      }
    }
    $bin = static::$test_run_id . $bin;
  }

  /**
   * Tell if cache persistence is enabled. If not, this cache
   * will behave as DRUPAL_STATIC until the end of request.
   *
   * Only enable this cache if the backend is DrupalWinCache
   * and the lock implementation is DrupalWinCache
   */
  public static function Enabled($refresh = FALSE) {
    if (static::$enabled === NULL || $refresh) {

      // Make sure _cache_get_object exists, if fastache
      // used out of database driver there is a chance that
      // cache storage might not yet be initialized.
      if (function_exists('_cache_get_object')) {

        // Only enabled storage if Cache Backend is DrupalWinCache or ChainedFastBackend.
        $object = _cache_get_object('fastcache');
        static::$enabled = is_a($object, \DrupalWinCache::class) || is_a($object, \ChainedFastBackend::class);
      }
      else {
        static::$enabled = FALSE;
      }
    }
    return static::$enabled;
  }

  /**
   * cache_clear_all wrapper.
   */
  public static function cache_clear_all($cid = NULL, $bin = NULL, $wildcard = FALSE, $volatile = FALSE) {
    static::FixKeyAndBin($cid, $bin);
    if (!$volatile && !isset(static::$fastcacheitems[$bin])) {
      static::cache_load_ensure($bin, TRUE);
    }

    // If the cache did not exist, it will still not be loaded.
    if (isset(static::$fastcacheitems[$bin])) {
      static::$fastcacheitems[$bin]
        ->clear($cid, $wildcard);
    }
  }

  /**
   * Ensure cache binary is statically loaded.
   */
  private static function cache_load_ensure($bin, $skiploadifempty = FALSE) {
    if (!isset(static::$fastcacheitems[$bin])) {

      // If storage is enabled, try to load from cache.
      if (static::Enabled()) {
        if ($cache = cache_get($bin, 'fastcache')) {
          static::$fastcacheitems[$bin] = new fastcacheitem($bin, $cache);
        }
        elseif ($skiploadifempty) {
          return;
        }
      }

      // If still not set, initialize.
      if (!isset(static::$fastcacheitems[$bin])) {
        static::$fastcacheitems[$bin] = new fastcacheitem($bin);
      }
    }
  }

  /**
   * cache_get wrapper.
   */
  public static function cache_get($cid, $bin = NULL) {
    static::FixKeyAndBin($cid, $bin);
    static::cache_load_ensure($bin);
    return static::$fastcacheitems[$bin]
      ->data_get($cid);
  }

  /**
   * cache_set wrapper.
   */
  public static function cache_set($cid, $data, $bin = NULL) {
    static::FixKeyAndBin($cid, $bin);
    static::cache_load_ensure($bin);
    if (static::$fastcacheitems[$bin]->changed == FALSE) {
      static::$fastcacheitems[$bin]->changed = TRUE;

      // Do persist or lock if it is not enabled!
      if (static::Enabled()) {
        static::$fastcacheitems[$bin]->persist = TRUE;
        if (static::$shutdown_registered == FALSE) {
          register_shutdown_function(array(
            'fastcache',
            'fastcache_persist',
          ));
          static::$shutdown_registered = TRUE;
        }
      }
    }
    static::$fastcacheitems[$bin]
      ->data_set($cid, $data);
  }

  /**
   * Called on shutdown, persists the cache
   * if necessary.
   */
  public static function fastcache_persist() {

    // Try to be the last of the last...
    register_shutdown_function(array(
      'fastcache',
      '_fastcache_persist',
    ));
  }

  /**
   * Persist the binaries.
   */
  public static function _fastcache_persist() {
    foreach (static::$fastcacheitems as &$cache) {
      if ($cache->persist == TRUE) {
        cache_set($cache->bin, $cache
          ->rawdata(), 'fastcache', CACHE_TEMPORARY);
      }

      // The binaries might be utilized on other shutdown functions...
      $cache->changed = FALSE;
      $cache->persist = FALSE;
    }

    // Fastcache may be reutilized during shutdown, make sure
    // persistence triggers run again.
    static::$shutdown_registered = FALSE;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
fastcache::$enabled	private static	property
fastcache::$fastcacheitems	private static	property
fastcache::$shutdown_registered	private static	property
fastcache::$test_run_id	private static	property	Test info is loaded at database bootstrap phase but this cache can be used earlier. Make sure we have a valid test prefix before any operation on the cache is performed.
fastcache::cache_clear_all	public static	function	cache_clear_all wrapper.
fastcache::cache_get	public static	function	cache_get wrapper.
fastcache::cache_load_ensure	private static	function	Ensure cache binary is statically loaded.
fastcache::cache_set	public static	function	cache_set wrapper.
fastcache::Enabled	public static	function	Tell if cache persistence is enabled. If not, this cache will behave as DRUPAL_STATIC until the end of request.
fastcache::fastcache_persist	public static	function	Called on shutdown, persists the cache if necessary.
fastcache::FixKeyAndBin	private static	function	Add test prefix to current binary key, and account for atomic items where $bin = NULL;
fastcache::_fastcache_persist	public static	function	Persist the binaries.