Cache API - Quick reference - Revision history

Mudrd8mz: Text replacement - "`" to ""`


2021-07-14T13:31:30Z
Text replacement - "<code php>" to "<syntaxhighlight lang="php">"

				
				
				
				
				
				← Older revision
				Revision as of 13:31, 14 July 2021
				
Line 4:
Line 4:
==Using a cache object== ==Using a cache object==
===Getting a cache instance for a definition=== ===Getting a cache instance for a definition===
<code php> <syntaxhighlight lang="php">
// Most basic // Most basic
$cache = cache::make('component', 'area'); $cache = cache::make('component', 'area');
Line 14:
Line 14:
===Getting an ad-hoc cache instance=== ===Getting an ad-hoc cache instance===
Using cache definitions is the recommended method. Ad-hoc caches should only be used where you have a rarely used cache, or insignificant cache. Typical use-case can be when you are refactoring some local static variables into MODE_REQUEST caches. Using cache definitions is the recommended method. Ad-hoc caches should only be used where you have a rarely used cache, or insignificant cache. Typical use-case can be when you are refactoring some local static variables into MODE_REQUEST caches.
<code php> <syntaxhighlight lang="php">
// Application cache // Application cache
$cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'component', 'area'); $cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'component', 'area');
Line 39:
Line 39:
===Get a key=== ===Get a key===
If you have many keys to retrieve you should use [[#Get many keys at once|get_many]]. If you have many keys to retrieve you should use [[#Get many keys at once|get_many]].
<code php> <syntaxhighlight lang="php">
// Get a cache instance // Get a cache instance
$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area'); $cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');
Line 52:
Line 52:
Not all cache stores will support fetching many keys at once, some stores will take the array of keys and process them one by one. Not all cache stores will support fetching many keys at once, some stores will take the array of keys and process them one by one.
If you have many keys to fetch it is recommended to use this still as cache stores that do support this will likely perform better. If you have many keys to fetch it is recommended to use this still as cache stores that do support this will likely perform better.
<code php> <syntaxhighlight lang="php">
$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area'); $cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');



Line 79:
Line 79:
===Store a key=== ===Store a key===
If you have many items to store you should use [[#Store many keys at once|set_many]]. If you have many items to store you should use [[#Store many keys at once|set_many]].
<code php> <syntaxhighlight lang="php">
// Get a cache instance // Get a cache instance
$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area'); $cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');
Line 93:
Line 93:
Note not all stores will support setting several items in a single transaction, stores that don't will process each item of the array separately. Note not all stores will support setting several items in a single transaction, stores that don't will process each item of the array separately.
It is still recommended to use this method if you have many items to set as those stores that do support it will likely perform better. It is still recommended to use this method if you have many items to set as those stores that do support it will likely perform better.
<code php> <syntaxhighlight lang="php">
// Get a cache instance // Get a cache instance
$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area'); $cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');
Line 113:
Line 113:
===Delete a key=== ===Delete a key===
If you have several keys you want to delete you should use [[#Delete many keys at once|delete_many]]. If you want to delete everything you should use [[#Delete all keys|purge]]. If you have several keys you want to delete you should use [[#Delete many keys at once|delete_many]]. If you want to delete everything you should use [[#Delete all keys|purge]].
<code php> <syntaxhighlight lang="php">
// Get a cache instance // Get a cache instance
$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area'); $cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');
Line 124:
Line 124:



===Delete many keys at once=== ===Delete many keys at once===
<code php> <syntaxhighlight lang="php">
// Get a cache instance // Get a cache instance
$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area'); $cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');
Line 137:
Line 137:
===Delete all keys=== ===Delete all keys===
It is not recommended to purge unless absolutely required, this will cause the store (plugin instance) being used by your cache to be purged. Not all stores can tell which keys belong to your cache and in that circumstance all keys in the store are deleted, not just the keys belonging to your cache, also the keys belonging to other caches using that same store. It is not recommended to purge unless absolutely required, this will cause the store (plugin instance) being used by your cache to be purged. Not all stores can tell which keys belong to your cache and in that circumstance all keys in the store are deleted, not just the keys belonging to your cache, also the keys belonging to other caches using that same store.
<code php> <syntaxhighlight lang="php">
// Get a cache instance // Get a cache instance
$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area'); $cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');
Line 147:
Line 147:
===Create a definition=== ===Create a definition===
Basic definition with just the required mode: Basic definition with just the required mode:
<code php> <syntaxhighlight lang="php">
$definitions = array( $definitions = array(
     // The name of the cache area is the key. The component/plugin will be picked up from the file location.      // The name of the cache area is the key. The component/plugin will be picked up from the file location.
Line 158:
Line 158:



Advanced definition: Advanced definition:
<code php> <syntaxhighlight lang="php">
$definitions = array( $definitions = array(
     // The name of the cache area is the key. The component/plugin will be picked up from the file location.      // The name of the cache area is the key. The component/plugin will be picked up from the file location.
Line 256:
Line 256:
==Invalidating keys from a cache== ==Invalidating keys from a cache==
===Invalidate keys using an event=== ===Invalidate keys using an event===
<code php> <syntaxhighlight lang="php">
cache_helper::invalidate_by_event('event1', array('key1', 'key2')); cache_helper::invalidate_by_event('event1', array('key1', 'key2'));
</syntaxhighlight> </syntaxhighlight>



===Invalidate keys using belonging to a definition=== ===Invalidate keys using belonging to a definition===
<code php> <syntaxhighlight lang="php">
// Identifiers for the definitions // Identifiers for the definitions
$identifiers = array( $identifiers = array(

`Mudrd8mz: Text replacement - "`" to ""

2021-07-14T13:02:49Z

Text replacement - "</code>" to "</syntaxhighlight>"

← Older revision		Revision as of 13:02, 14 July 2021
Line 10:		Line 10:
	// Using identifiers		// Using identifiers
	$cache = cache::make('component', 'area', array('dbfamily' => 'pgsql'));		$cache = cache::make('component', 'area', array('dbfamily' => 'pgsql'));
	</~~code~~>		</syntaxhighlight>

	===Getting an ad-hoc cache instance===		===Getting an ad-hoc cache instance===
Line 35:		Line 35:
	$cache = cache::make_from_params(cache_store::MODE_REQUEST, 'component', 'area', array(),		$cache = cache::make_from_params(cache_store::MODE_REQUEST, 'component', 'area', array(),
	array('simplekeys' => true, 'simpledata' => true));		array('simplekeys' => true, 'simpledata' => true));
	</~~code~~>		</syntaxhighlight>

	===Get a key===		===Get a key===
Line 47:		Line 47:

	// Data returned will be what ever was stored, or false if it was not in the cache.		// Data returned will be what ever was stored, or false if it was not in the cache.
	</~~code~~>		</syntaxhighlight>

	===Get many keys at once===		===Get many keys at once===
Line 75:		Line 75:
	// 'key3' => 'data3'		// 'key3' => 'data3'
	// )		// )
	</~~code~~>		</syntaxhighlight>

	===Store a key===		===Store a key===
Line 88:		Line 88:

	// Result will be true on success, false otherwise.		// Result will be true on success, false otherwise.
	</~~code~~>		</syntaxhighlight>

	===Store many keys at once===		===Store many keys at once===
Line 109:		Line 109:

	// Result will be an int, the number of items successfully set.		// Result will be an int, the number of items successfully set.
	</~~code~~>		</syntaxhighlight>

	===Delete a key===		===Delete a key===
Line 121:		Line 121:

	// Result will be true on success, false otherwise.		// Result will be true on success, false otherwise.
	</~~code~~>		</syntaxhighlight>

	===Delete many keys at once===		===Delete many keys at once===
Line 133:		Line 133:
	$result = $cache->delete_many($keys);		$result = $cache->delete_many($keys);
	// $result will contain the number of items successfully deleted.		// $result will contain the number of items successfully deleted.
	</~~code~~>		</syntaxhighlight>

	===Delete all keys===		===Delete all keys===
Line 143:		Line 143:
	$result = $cache->purge();		$result = $cache->purge();
	// $result will contain the number of items successfully deleted.		// $result will contain the number of items successfully deleted.
	</~~code~~>		</syntaxhighlight>

	===Create a definition===		===Create a definition===
Line 155:		Line 155:
	)		)
	);		);
	</~~code~~>		</syntaxhighlight>

	Advanced definition:		Advanced definition:
Line 250:		Line 250:
	)		)
	);		);
	</~~code~~>		</syntaxhighlight>

	A better explanation of the cache definition can be found on the [[Cache API#The definition\|Cache API]] page		A better explanation of the cache definition can be found on the [[Cache API#The definition\|Cache API]] page
Line 258:		Line 258:
	<code php>		<code php>
	cache_helper::invalidate_by_event('event1', array('key1', 'key2'));		cache_helper::invalidate_by_event('event1', array('key1', 'key2'));
	</~~code~~>		</syntaxhighlight>

	===Invalidate keys using belonging to a definition===		===Invalidate keys using belonging to a definition===
Line 271:		Line 271:

	cache_helper::invalidate_by_definition('component', 'area', $identifiers, $keys);		cache_helper::invalidate_by_definition('component', 'area', $identifiers, $keys);
	</~~code~~>		</syntaxhighlight>

	==Miscellaneous==		==Miscellaneous==
	* Checkout important [https://moodle.org/local/chatlogs/index.php?q=cache discussion about the Cache API at the Moodle developer (Telegram) chat]		* Checkout important [https://moodle.org/local/chatlogs/index.php?q=cache discussion about the Cache API at the Moodle developer (Telegram) chat]

Nadavkav at 10:00, 16 April 2020

2020-04-16T10:00:11Z

← Older revision		Revision as of 10:00, 16 April 2020
Line 272:		Line 272:
	cache_helper::invalidate_by_definition('component', 'area', $identifiers, $keys);		cache_helper::invalidate_by_definition('component', 'area', $identifiers, $keys);
	</code>		</code>

			==Miscellaneous==
			* Checkout important [https://moodle.org/local/chatlogs/index.php?q=cache discussion about the Cache API at the Moodle developer (Telegram) chat]

Nadavkav: /* Delete many keys at once */

2018-01-06T11:39:32Z

Delete many keys at once

← Older revision		Revision as of 11:39, 6 January 2018
Line 128:		Line 128:
	$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');		$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');

	// ~~Key~~ can be an int or string		// Array of Keys can be an int or string
	~~// Data can be anything~~		$keys = array('key1', 'key2');
	$~~result~~ = ~~$cache->delete_many~~('~~key~~', '~~data~~');

			$result = $cache->delete_many($keys);
	// $result will contain the number of items successfully deleted.		// $result will contain the number of items successfully deleted.
	</code>		</code>

Nadavkav: /* Delete a key */

2018-01-06T11:36:44Z

Delete a key

← Older revision		Revision as of 11:36, 6 January 2018
Line 117:		Line 117:
	$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');		$cache = cache::make(cache_store::MODE_APPLICATION, 'component', 'area');

	// Key can be an int or string		// Key can be an int or string
	~~// Data can be anything~~		$result = $cache->delete('key');
	$result = $cache->~~set~~('key~~', 'data~~');

	// Result will be true on success, false otherwise.		// Result will be true on success, false otherwise.
	</code>		</code>

	===Delete many keys at once===		===Delete many keys at once===
	<code php>		<code php>

Berserkk: /* Getting an ad-hoc cache instance */

2016-01-05T04:55:16Z

Getting an ad-hoc cache instance

← Older revision		Revision as of 04:55, 5 January 2016
Line 29:		Line 29:

	// Using persistence so that the cache instance is stored for future use/request		// Using persistence so that the cache instance is stored for future use/request
	$cache = cache::~~make_with_params~~(~~cache~~::MODE_APPLICATION, 'component', 'area', array(),		$cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'component', 'area', array(),
	array('persistent' => true));		array('persistent' => true));

Emerrill: /* Create a definition */ Updating definition with current options.

2014-05-18T01:57:44Z

Create a definition: Updating definition with current options.

← Older revision		Revision as of 01:57, 18 May 2014
Line 166:		Line 166:

	// All of the following options are default		// All of the following options are default

			// [bool] Set to true if your cache will only use simple keys for its items.
			// Simple keys consist of digits, underscores and the 26 chars of the english language. a-zA-Z0-9_
			// If true the keys won't be hashed before being passed to the cache store for gets/sets/deletes. It will be
			// better for performance and possible only becase we know the keys are safe.
			'simplekeys' => false,

			// [bool] If set to true we know that the data is scalar or array of scalar.
			'simpledata' => false,

	// [array] An array of identifiers that must be provided to the cache when it is created.		// [array] An array of identifiers that must be provided to the cache when it is created.
Line 213:		Line 222:
	// or when you are converting existing code to the cache and need to access the cache within functions but don't want		// or when you are converting existing code to the cache and need to access the cache within functions but don't want
	// to add it as an argument to the function.		// to add it as an argument to the function.
	'~~persistent~~' => false,		'staticacceleration' => false,

	// [int] This supplements the above setting by limiting the number of items in the caches persistent array of items.		// [int] This supplements the above setting by limiting the number of items in the caches persistent array of items.
	// Tweaking this setting lower will allow you to minimise the memory implications above while hopefully still managing to		// Tweaking this setting lower will allow you to minimise the memory implications above while hopefully still managing to
	// offset calls to the cache store.		// offset calls to the cache store.
	'~~persistentmaxsize~~' => null,		'staticaccelerationsize' => null,

	// [int] A time to live for the data (in seconds). It is strongly recommended that you don't make use of this and		// [int] A time to live for the data (in seconds). It is strongly recommended that you don't make use of this and
Line 232:		Line 241:
	// [array] An array of events that should cause this cache to invalidate some or all of the items within it.		// [array] An array of events that should cause this cache to invalidate some or all of the items within it.
	'invalidationevents' => array('event1', 'event2'),		'invalidationevents' => array('event1', 'event2'),

			// [int] The sharing options that are appropriate for this definition. Should be the sum of the possible options.
			'sharingoptions' => cache_definition::SHARING_DEFAULT,

			// [int] The default sharing option to use. It's highly recommended that you don't set this unless there is a very
			// specific reason not to use the system default.
			'defaultsharing' => cache_definition::SHARING_DEFAULT,
	)		)
	);		);

Ybozhko: /* Invalidate keys using belonging to a definition */

2013-08-22T02:45:17Z

Invalidate keys using belonging to a definition

← Older revision		Revision as of 02:45, 22 August 2013
Line 254:		Line 254:
	$keys = array('key1', 'key2');		$keys = array('key1', 'key2');

	cache_helper::~~invalidate_by_event~~('component', 'area', $identifiers, $keys);		cache_helper::invalidate_by_definition('component', 'area', $identifiers, $keys);
	</code>		</code>

Mudrd8mz: Fix method name and provide an example for ad-hoc caches usage

2013-02-12T08:13:33Z

Fix method name and provide an example for ad-hoc caches usage

← Older revision		Revision as of 08:13, 12 February 2013
Line 13:		Line 13:

	===Getting an ad-hoc cache instance===		===Getting an ad-hoc cache instance===
	Using cache definitions is the recommended method. Ad-hoc caches should only be used where you have a rarely used cache, or insignificant cache.		Using cache definitions is the recommended method. Ad-hoc caches should only be used where you have a rarely used cache, or insignificant cache. Typical use-case can be when you are refactoring some local static variables into MODE_REQUEST caches.
	<code php>		<code php>
	// Application cache		// Application cache
	$cache = cache::~~make_with_params~~(cache_store::MODE_APPLICATION, 'component', 'area');		$cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'component', 'area');

	// Session cache		// Session cache
	$cache = cache::~~make_with_params~~(cache_store::MODE_SESSION, 'component', 'area');		$cache = cache::make_from_params(cache_store::MODE_SESSION, 'component', 'area');

	// Request cache		// Request cache
	$cache = cache::~~make_with_params~~(cache_store::MODE_REQUEST, 'component', 'area');		$cache = cache::make_from_params(cache_store::MODE_REQUEST, 'component', 'area');

	// Using identifiers		// Using identifiers
	$cache = cache::~~make_with_params~~(cache_store::MODE_APPLICATION, 'component', 'area', array('dbfamily' => 'pgsql'));		$cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'component', 'area',
			array('dbfamily' => 'pgsql'));

	// Using persistence so that the cache instance is stored for future use/request		// Using persistence so that the cache instance is stored for future use/request
	$cache = cache::make_with_params(cache::MODE_APPLICATION, 'component', 'area', array(), true);		$cache = cache::make_with_params(cache::MODE_APPLICATION, 'component', 'area', array(),
			array('persistent' => true));

			// Using a request cache to replace static variable
			$cache = cache::make_from_params(cache_store::MODE_REQUEST, 'component', 'area', array(),
			array('simplekeys' => true, 'simpledata' => true));
	</code>		</code>

TimHunt: /* Getting an ad-hoc cache instance */

2012-08-30T07:06:19Z