MySQL 5.6 Reference Manual Including MySQL NDB Cluster 7.3-7.4 Reference Guide
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' => [ '198.51.100.100:11211', '198.51.100.101:11211', '198.51.100.102:11211', ], };
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 Generic Method |
---|---|
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:
shell> memcached-sakila.pl "ROCK INSTINCT" Film data loaded from Memcached