Using MariaDB and memcached with Perl

The Cache::Memcached module provides a native interface to the Memcache protocol, and provides support for the core functions offered by memcached. Install the module using your operating system's package management system, or using CPAN:

root-shell> perl -MCPAN -e 'install Cache::Memcached'

To use memcached from Perl through the Cache::Memcached module, first create a new Cache::Memcached object that defines the list of servers and other parameters for the connection. The only argument is a hash containing the options for the cache interface. For example, to create a new instance that uses three memcached servers:

use Cache::Memcached;
my $cache = new Cache::Memcached {
 'servers' => [
 '192.168.0.100:11211',
 '192.168.0.101:11211',
 '192.168.0.102:11211',
 ],
};

Note

When using the Cache::Memcached interface with multiple servers, the API automatically performs certain operations across all the servers in the group. For example, getting statistical information through Cache::Memcached returns a hash that contains data on a host-by-host basis, as well as generalized statistics for all the servers in the group.

You can set additional properties on the cache object instance when it is created by specifying the option as part of the option hash. Alternatively, you can use a corresponding method on the instance:

servers or method set_servers(): Specifies the list of the servers to be used. The servers list should be a reference to an array of servers, with each element as the address and port number combination (separated by a colon). You can also specify a local connection through a UNIX socket (for example /tmp/sock/memcached). To specify the server with a weight (indicating how much more frequently the server should be used during hashing), specify an array reference with the memcached server instance and a weight number. Higher numbers give higher priority.
compress_threshold or method set_compress_threshold(): Specifies the threshold when values are compressed. Values larger than the specified number are automatically compressed (using zlib) during storage and retrieval.
no_rehash or method set_norehash(): Disables finding a new server if the original choice is unavailable.
readonly or method set_readonly(): Disables writes to the memcached servers.

Once the Cache::Memcached object instance has been configured, you can use the set() and get() methods to store and retrieve information from the memcached servers. Objects stored in the cache are automatically serialized and deserialized using the Storable module.

The Cache::Memcached interface supports the following methods for storing/retrieving data, and relate to the generic methods as shown in the table.

`Cache::Memcached` Function	Equivalent to
`get()`	Generic `get()`.
`get_multi(keys)`	Gets multiple `keys` from memcache using just one query. Returns a hash reference of key/value pairs.
`set()`	Generic `set()`.
`add()`	Generic `add()`.
`replace()`	Generic `replace()`.
`delete()`	Generic `delete()`.
`incr()`	Generic `incr()`.
`decr()`	Generic `decr()`.

Below is a complete example for using memcached with Perl and the Cache::Memcached module:

#!/usr/bin/perl use Cache::Memcached;
use DBI;
use Data::Dumper;
# Configure the memcached server my $cache = new Cache::Memcached {
 'servers' => [
 'localhost:11211',
 ],
 };
# Get the film name from the command line
# memcached keys must not contain spaces, so create
# a key name by replacing spaces with underscores my $filmname = shift or die 'Must specify the film name\n';
my $filmkey = $filmname;
$filmkey =~ s/ /_/;
# Load the data from the cache my $filmdata = $cache->get($filmkey);
# If the data wasn't in the cache, then we load it from the database if (!defined($filmdata))
{
 $filmdata = load_filmdata($filmname);
 if (defined($filmdata))
 {
# Set the data into the cache, using the key
 if ($cache->set($filmkey,$filmdata))
 {
 print STDERR 'Film data loaded from database and cached\n';
 }
 else
 {
 print STDERR 'Couldn't store to cache\n';
 }
 }
 else
 {
 die 'Couldn't find $filmname\n';
 }
}
else
{
 print STDERR 'Film data loaded from Memcached\n';
}
sub load_filmdata
{
 my ($filmname) = @_;
 my $dsn = 'DBI:mysql:database=sakila;host=localhost;port=3306';
 $dbh = DBI->connect($dsn, 'sakila','password');
 my ($filmbase) = $dbh->selectrow_hashref(sprintf('select * from film where title = %s',
 $dbh->quote($filmname)));
 if (!defined($filmname))
 {
 return (undef);
 }
 $filmbase->{stars} =
 $dbh->selectall_arrayref(sprintf('select concat(first_name,' ',last_name) ' .
 'from film_actor left join (actor) ' .
 'on (film_actor.actor_id = actor.actor_id) ' .
 ' where film_id=%s',
 $dbh->quote($filmbase->{film_id})));
 return($filmbase);
}

The example uses the Sakila database, obtaining film data from the database and writing a composite record of the film and actors to memcached. When calling it for a film does not exist, you get this result:

shell> memcached-sakila.pl 'ROCK INSTINCT'
Film data loaded from database and cached

When accessing a film that has already been added to the cache:

Using MariaDB and memcached with Perl

Retornar