Redis(3pm)

📦

version 2.000 · 7 versions

2.000 · debian bookworm, debian trixie, ubuntu noble, ubuntu resolute, ubuntu stonking (latest)
2.000 · epel 9
2.000 · epel 10
2.000 · alpine 3.24
2.000 · fedora 43
1.9990 · ubuntu jammy
2.000 · fedora 44

, in debian bookworm, debian trixie, ubuntu noble, ubuntu resolute, ubuntu stonking

💖 Redis(3pm) — the Perl binding for Redis, bestie edition 💖

okay so like. you want to talk to Redis. from Perl. and you want it to be easy. that's literally this module, Redis, and it's documented as a 3pm man page (Perl module docs, you know the vibe). let's get into it 🫶

✨ NAME ✨

Redis — Perl binding for Redis database. no cap, that's the whole pitch 💅

🌸 VERSION 🌸

version 2.000 — that's the version, periodt.

🎀 SYNOPSIS 🎀

okay bestie, this is the part where we just vibe and look at all the ways you can spin up a connection. everything here is copy-paste-able, go wild:

## Defaults to $ENV{REDIS_SERVER} or 127.0.0.1:6379
my $redis = Redis->new;

my $redis = Redis->new(server => 'redis.example.com:8080');

## Set the connection name (requires Redis 2.6.9)
my $redis = Redis->new(
  server => 'redis.example.com:8080',
  name => 'my_connection_name',
);
my $generation = 0;
my $redis = Redis->new(
  server => 'redis.example.com:8080',
  name => sub { "cache-$$-".++$generation },
);

## Use UNIX domain socket
my $redis = Redis->new(sock => '/path/to/socket');

## Connect to Redis over a secure SSL/TLS channel.  See
## IO::Socket::SSL documentation for more information
## about SSL_verify_mode parameter.
my $redis = Redis->new(
    server => 'redis.tls.example.com:8080',
    ssl => 1,
    SSL_verify_mode => SSL_VERIFY_PEER,
);

## Enable auto-reconnect
## Try to reconnect every 1s up to 60 seconds until success
## Die if you can't after that
my $redis = Redis->new(reconnect => 60, every => 1_000_000);

## Try each 100ms up to 2 seconds (every is in microseconds)
my $redis = Redis->new(reconnect => 2, every => 100_000);

## Enable connection timeout (in seconds)
my $redis = Redis->new(cnx_timeout => 60);

## Enable read timeout (in seconds)
my $redis = Redis->new(read_timeout => 0.5);

## Enable write timeout (in seconds)
my $redis = Redis->new(write_timeout => 1.2);

## Connect via a list of Sentinels to a given service
my $redis = Redis->new(sentinels => [ '127.0.0.1:12345' ], service => 'mymaster');

## Same, but with connection, read and write timeout on the sentinel hosts
my $redis = Redis->new( sentinels => [ '127.0.0.1:12345' ], service => 'mymaster',
                        sentinels_cnx_timeout => 0.1,
                        sentinels_read_timeout => 1,
                        sentinels_write_timeout => 1,
                      );

## Use all the regular Redis commands, they all accept a list of
## arguments
## See https://redis.io/commands for full list
$redis->get('key');
$redis->set('key' => 'value');
$redis->sort('list', 'DESC');
$redis->sort(qw{list LIMIT 0 5 ALPHA DESC});

## Add a coderef argument to run a command in the background
$redis->sort(qw{list LIMIT 0 5 ALPHA DESC}, sub {
  my ($reply, $error) = @_;
  die "Oops, got an error: $error\n" if defined $error;
  print "$_\n" for @$reply;
});
long_computation();
$redis->wait_all_responses;
## or
$redis->wait_one_response();

## Or run a large batch of commands in a pipeline
my %hash = _get_large_batch_of_commands();
$redis->hset('h', $_, $hash{$_}, sub {}) for keys %hash;
$redis->wait_all_responses;

## Publish/Subscribe
$redis->subscribe(
  'topic_1',
  'topic_2',
  sub {
    my ($message, $topic, $subscribed_topic) = @_

      ## $subscribed_topic can be different from topic if
      ## you use psubscribe() with wildcards
  }
);
$redis->psubscribe('nasdaq.*', sub {...});

## Blocks and waits for messages, calls subscribe() callbacks
##  ... forever
my $timeout = 10;
$redis->wait_for_messages($timeout) while 1;

##  ... until some condition
my $keep_going = 1; ## other code will set to false to quit
$redis->wait_for_messages($timeout) while $keep_going;

$redis->publish('topic_1', 'message');

like, look at all of that. connection names, sockets, TLS, auto-reconnect, timeouts, sentinels, pipelining, pub/sub — it's giving range 🔥

🦋 DESCRIPTION 🦋

Pure perl bindings for <https://redis.io/>. pure perl, no compiled C extension nonsense, we love that for us 💖

This version supports protocol 2.x (multi-bulk) or later of Redis available at <https://github.com/antirez/redis/>.

This documentation lists commands which are exercised in test suite, but additional commands will work correctly since protocol specifies enough information to support almost all commands with same piece of code with a little help of "AUTOLOAD". translation: the docs show you what's been battle-tested, but basically any other command is gonna work anyway because the protocol just hands over enough info, and "AUTOLOAD" picks up the slack. iconic behavior honestly ✨

🌈 PIPELINING 🌈

so normally? you run a command, you sit there waiting for the response. very "watching paint dry" energy. but if you're firing off a lot of requests, it's way more efficient to do the thing Redis calls pipelining: yeet a bunch of commands at Redis without waiting for any responses, then collect all the responses as they come back. main character efficiency 💅

To use pipelining, add a coderef argument as the last argument to a command method call:

$r->set('foo', 'bar', sub {});

Pending responses to pipelined commands are processed in a single batch, as soon as at least one of the following conditions holds:

A non-pipelined (synchronous) command is called on the same connection
A pub/sub subscription command (one of "subscribe", "unsubscribe", "psubscribe", or "punsubscribe") is about to be called on the same connection.
One of "wait_all_responses" or "wait_one_response" methods is called explicitly.

The coderef you supply to a pipelined command method is invoked once the response is available. It takes two arguments, $reply and $error. If $error is defined, it contains the text of an error reply sent by the Redis server. Otherwise, $reply is the non-error reply. For almost all commands, that means it's "undef", or a defined but non-reference scalar, or an array ref of any of those; but see "keys", "info", and "exec".

Note the contrast with synchronous commands, which throw an exception on receipt of an error reply, or return a non-error reply directly. so like, pipelined = errors get handed to you, sync = errors get thrown at you. different vibes, both valid 🫶

The fact that pipelined commands never throw an exception can be particularly useful for Redis transactions; see "exec". 👑

🧚 ENCODING 🧚

There is no encoding feature anymore, it has been deprecated and finally removed. This module consider that any data sent to the Redis server is a binary data. And it doesn't do anything when getting data from the Redis server.

So, if you are working with character strings, you should pre-encode or post-decode it if needed !

okay so real talk bestie: the encoding feature is gone. deprecated, then fully removed, RIP 💀. this module treats literally everything you send to Redis as binary data, and it does nothing to data coming back from Redis. so if you're dealing with character strings, that's on you — pre-encode on the way in, post-decode on the way out, fr fr.

🎀 CONSTRUCTOR 🎀

okay bestie, this is where the magic literally begins. this is how you make a Redis object. look at all these flavours:

my $r = Redis->new; # $ENV{REDIS_SERVER} or 127.0.0.1:6379

my $r = Redis->new( server => '192.168.0.1:6379', debug => 0 );
my $r = Redis->new( server => '192.168.0.1:6379', encoding => undef );
my $r = Redis->new( server => '192.168.0.1:6379', ssl => 1, SSL_verify_mode => SSL_VERIFY_PEER );
my $r = Redis->new( sock => '/path/to/sock' );
my $r = Redis->new( reconnect => 60, every => 5000 );
my $r = Redis->new( password => 'boo' );
my $r = Redis->new( on_connect => sub { my ($redis) = @_; ... } );
my $r = Redis->new( name => 'my_connection_name' );
my $r = Redis->new( name => sub { "cache-for-$$" });

my $redis = Redis->new(sentinels => [ '127.0.0.1:12345', '127.0.0.1:23456' ],
                       service => 'mymaster');

## Connect via a list of Sentinels to a given service
my $redis = Redis->new(sentinels => [ '127.0.0.1:12345' ], service => 'mymaster');

## Same, but with connection, read and write timeout on the sentinel hosts
my $redis = Redis->new( sentinels => [ '127.0.0.1:12345' ], service => 'mymaster',
                        sentinels_cnx_timeout => 0.1,
                        sentinels_read_timeout => 1,
                        sentinels_write_timeout => 1,
                      );

pick your fighter. 💅

✨ new ✨

🖥️ "server"

the "server" param is like, which Redis are we even talking to? it's TCP, and you write it in 'IP:PORT' format. if you don't pass "server" at all, we'll go looking for the "REDIS_SERVER" environment variable. and if that's not there either, we just default to '127.0.0.1:6379'. slay, sensible defaults.

OR — plot twist — you can use the "sock" parameter to hand over the path of the UNIX domain socket your Redis server is vibing on.

OR — second plot twist — you can use "sentinels" + "service" to give a list of sentinels to hit up and try to get the address of the service name you want. heads up: "sentinels" has to be an ArrayRef and "service" has to be an Str. no cap.

and yes, "REDIS_SERVER" works for UNIX domain sockets too 🫶 these are the formats we accept:

/path/to/sock
unix:/path/to/sock
127.0.0.1:11011
tcp:127.0.0.1:11011

🔁 "reconnect", "every"

setting "reconnect" turns on auto-reconnection mode. if we can't connect to the Redis server, or if a network write fails, we go into retry mode. we'll try a fresh connection every "every" microseconds (default is 1 ms), for up to "reconnect" seconds. obsessed with resilience honestly.

⚠️ but know this: read errors will always throw an exception, and they won't trigger a retry until the next command gets sent. that's just how it is, bestie.

and if we still can't re-establish a connection after "reconnect" seconds? exception. thrown. periodt.

🛡️ "conservative_reconnect"

"conservative_reconnect" is the safe-girl option — it makes sure reconnection only gets attempted when there's no pending command in flight. here's the scenario that'll ruin your day: you're doing $redis->incr('key'), the server fully understood and processed the command, but the network drops right before the server replies. so the command did happen, but the client has no idea. if reconnect is enabled, the Redis client will reconnect and send that incr command again. and if it succeeds, congratulations, your key got incremented twice. 😭

to dodge that whole situation, set "conservative_reconnect" to a true value. then the client only reconnects if no request is pending. otherwise it dies with this message: reconnect disabled while responses are pending and safe reconnect mode enabled. blunt, but honest.

⏱️ "cnx_timeout"

"cnx_timeout" turns on connection timeout. the Redis client will wait at most that many seconds (fractional is fine, she's flexible) before giving up on connecting to a server.

📡 "sentinels_cnx_timeout"

"sentinels_cnx_timeout" is the same deal but for sentinel connections. when you're using the sentinels feature, the Redis client waits at most that many seconds (fractional totally fine) before giving up on connecting to a sentinel. Default: 0.1

📖 "read_timeout"

"read_timeout" enables read timeout. the Redis client waits at most that many seconds (fractional, yes) before giving up when reading from the server.

📡📖 "sentinels_read_timeout"

"sentinels_read_timeout" is the sentinel version. when using the sentinels feature, the client waits at most that many seconds (fractional, bestie) before giving up when reading from a sentinel server. Default: 1

✍️ "write_timeout"

"write_timeout" enables write timeout. the Redis client waits at most that many seconds (fractional, obviously) before giving up when reading from the server.

📡✍️ "sentinels_write_timeout"

"sentinels_write_timeout" — sentinel edition. when using the sentinels feature, the client waits at most that many seconds (fractional!) before giving up when reading from a sentinel server. Default: 1

🔑 "password"

if your Redis server is like "who even are you", use the "password" attribute. after every established connection (whether it's the first one or a reconnect), the Redis AUTH command gets sent to the server. and if the password is wrong? exception thrown, and reconnect gets disabled. no second chances with bad credentials, that's the vibe.

🎣 "on_connect"

you can also hand over a code reference that runs immediately after each successful connection. the "on_connect" attribute is where that code ref lives, and it gets called with the Redis object as its first parameter.

🚫 "no_auto_connect_on_new"

give "no_auto_connect_on_new" and new won't implicitly call $obj->connect for you — you'll have to do it yourself. why would you want that? it's lowkey perfect for measuring how long connection setup actually takes, so you can configure "cnx_timeout" like a responsible queen.

🚫📋 "no_sentinels_list_update"

you can also pass "no_sentinels_list_update". by default (i.e. without this option), whenever we successfully contact a sentinel server, the Redis client asks it for the list of sentinels known for that service, and merges it into its own list of sentinels (that's the "sentinels" attribute). want none of that? set "no_sentinels_list_update" to a true value and it stops.

🏷️ "name"

you can set a name for each connection and honestly it's so useful for debugging, via the "CLIENT LIST" command. use the "name" parameter. it takes either a scalar value or a CodeRef — if it's a CodeRef, it gets called after each connection with the Redis object, and it should return the connection name to use. if it returns an undefined value, Redis just won't set the connection name. simple as.

⚠️ okay important: there are restrictions on the name you can set, and the biggest one is no spaces. the CLIENT SETNAME documentation (https://redis.io/commands/client-setname) has all the juicy details.

this feature is safe with all versions of Redis servers, but if "CLIENT SETNAME" support isn't available (that's Redis servers 2.6.9 and above only, bestie), the name parameter just gets ignored. no drama.

🔒 "ssl"

want to connect to Redis over SSL/TLS? set this flag — but only if your target Redis server or cluster is actually set up to support SSL/TLS. it requires IO::Socket::SSL to be installed on the client. and it's off by default.

🔏 "SSL_verify_mode"

this one applies when the "ssl" flag is set. it sets the verification mode for the peer certificate. it's compatible with the parameter of the same name in IO::Socket::SSL. cute and consistent.

🐛 "debug"

the "debug" parameter sends debug info to STDERR, including all the interactions with the server. you can also flip debug on with the "REDIS_DEBUG" environment variable. peak transparency honestly.

🔌 CONNECTION HANDLING 🔌

connect

$r->connect;

connects to the Redis server. this already happens by default when the object is constructed with new(), unless no_auto_connect_on_new has been set. go peep that option in the new() constructor section above. 👑

quit

$r->quit;

closes the connection to the server. heads up bestie: the quit method does not support pipelined operation.

ping

$r->ping || die "no server?";

also important: the ping method does not support pipelined operation either.

📬 PIPELINE MANAGEMENT 📬

wait_all_responses

waits until all pending pipelined responses have been received, and invokes the pipeline callback for each one. see "PIPELINING". 🌸

wait_one_response

waits until the first pending pipelined response has been received, and invokes its callback. see "PIPELINING". one at a time, methodically, we love a patient icon. ✨

Okay so when one of subscribe or psubscribe is used, the Redis object will enter PubSub mode. When in PubSub mode only commands in this section, plus quit, will be accepted. That's the rule, bestie. 💅

If you plan on using PubSub and other Redis functions, you should use two Redis objects, one dedicated to PubSub and the other for regular commands. Do not make one object do both, it's giving chaos. 🫶

All Pub/Sub commands receive a callback as the last parameter. This callback receives three arguments:

The published message.
The topic over which the message was sent.
The subscribed topic that matched the topic for the message. With subscribe these last two are the same, always. But with psubscribe, this parameter tells you the pattern that matched.

See the Pub-Sub notes <https://redis.io/topics/pubsub> for more information about the messages you will receive on your callbacks after each subscribe, unsubscribe, psubscribe and punsubscribe. ✨

`publish`

$r->publish($topic, $message);

Publishes the $message to the $topic. Drop it like it's hot. 🔥

$r->subscribe(
    @topics_to_subscribe_to,
    my $savecallback = sub {
      my ($message, $topic, $subscribed_topic) = @_;
      ...
    },
);

Subscribe one or more topics. Messages published into one of them will be received by Redis, and the specified callback will be executed. Slay. 💖

`unsubscribe`

$r->unsubscribe(@topic_list, $savecallback);

Stops receiving messages via $savecallback for all the topics in @topic_list.

WARNING: it is important that you give the same callback that you used for subscription. The value of the CodeRef must be the same, as this is how internally the code identifies it. No cap, if you pass a different one it won't work. 😭

`psubscribe`

my @topic_matches = ('prefix1.*', 'prefix2.*');
$r->psubscribe(@topic_matches, my $savecallback = sub { my ($m, $t, $s) = @_; ... });

Subscribes a pattern of topics. All messages to topics that match the pattern will be delivered to the callback. Pattern matching? We love to see it. 🌸

`punsubscribe`

my @topic_matches = ('prefix1.*', 'prefix2.*');
$r->punsubscribe(@topic_matches, $savecallback);

Stops receiving messages via $savecallback for all the topics pattern matches in @topic_list.

WARNING: it is important that you give the same callback that you used for subscription. The value of the CodeRef must be the same, as this is how internally the code identifies it. Yes bestie, same energy as unsubscribe. 💅

`is_subscriber`

if ($r->is_subscriber) { say "We are in Pub/Sub mode!" }

Returns true if we are in Pub/Sub mode. Vibe check passed. ✅

`wait_for_messages`

my $keep_going = 1; ## Set to false somewhere to leave the loop
my $timeout = 5;
$r->wait_for_messages($timeout) while $keep_going;

Blocks, waits for incoming messages and delivers them to the appropriate callbacks. It's giving patient queen. 👑

Requires a single parameter, the number of seconds to wait for messages. Use 0 to wait for ever. If a positive non-zero value is used, it will return after that amount of seconds without a single notification.

Please note that the timeout is not a commitment to return control to the caller at most each timeout seconds, but more an idle timeout, where control will return to the caller if Redis is idle (as in no messages were received during the timeout period) for more than timeout seconds. So don't expect it to be clockwork, okay? 🕰️

The wait_for_messages call returns the number of messages processed during the run.

🚨 IMPORTANT NOTES ON METHODS 🚨

methods that return multiple values

When a method returns more than one value, it checks the context and returns either a list of values or an ArrayRef. Context is everything, bestie. 💜

transaction-handling methods

Warning: the behaviour of the TRANSACTIONS commands when combined with pipelining is still under discussion, and you should NOT use them at the same time just now. I'm serious, don't do it. 💀

You can follow the discussion to see the open issues with this <https://github.com/PerlRedis/perl-redis/issues/17>.

`exec`

my @individual_replies = $r->exec;

exec has special behaviour when run in a pipeline: the $reply argument to the pipeline callback is an array ref whose elements are themselves [$reply, $error] pairs. This means that you can accurately detect errors yielded by any command in the transaction, and without any exceptions being thrown. So you get the tea on every command. 🍵

`keys`

my @keys = $r->keys( '*glob_pattern*' );
my $keys = $r->keys( '*glob_pattern*' ); # count of matching keys

Note that synchronous keys calls in a scalar context return the number of matching keys (not an array ref of matching keys as you might expect). This does not apply in pipelined mode: assuming the server returns a list of keys, as expected, it is always passed to the pipeline callback as an array ref. Sneaky, but now you know. 🙈

hashes

Hashes in Redis cannot be nested as in perl, if you want to store a nested hash, you need to serialize the hash first. If you want to have a named hash, you can use Redis-hashes. You will find an example in the tests of this module t/01-basic.t. Go look, it's there. 🎀

`eval`

Note that this command sends the Lua script every time you call it. See evalsha and script_load for an alternative. Efficiency who? We know her. ✨

`info`

my $info_hash = $r->info;

The info method is unique in that it decodes the server's response into a hashref, if possible. This decoding happens in both synchronous and pipelined modes. Iconic behaviour, honestly. 👑

🗝️ KEYS 🗝️

`del`

$r->del(key [key ...])

Delete a key (see <https://redis.io/commands/del>)

`dump`

$r->dump(key)

Return a serialized version of the value stored at the specified key. (see <https://redis.io/commands/dump>)

`exists`

$r->exists(key)

Determine if a key exists (see <https://redis.io/commands/exists>)

`expire`

$r->expire(key, seconds)

Set a key's time to live in seconds (see <https://redis.io/commands/expire>)

`expireat`

$r->expireat(key, timestamp)

Set the expiration for a key as a UNIX timestamp (see <https://redis.io/commands/expireat>)

`keys`

$r->keys(pattern)

Find all keys matching the given pattern (see <https://redis.io/commands/keys>)

`migrate`

$r->migrate(host, port, key, destination-db, timeout, [COPY], [REPLACE])

Atomically transfer a key from a Redis instance to another one. (see <https://redis.io/commands/migrate>)

`move`

$r->move(key, db)

Move a key to another database (see <https://redis.io/commands/move>)

`object`

$r->object(subcommand, [arguments [arguments ...]])

Inspect the internals of Redis objects (see <https://redis.io/commands/object>)

`persist`

$r->persist(key)

Remove the expiration from a key (see <https://redis.io/commands/persist>)

`pexpire`

$r->pexpire(key, milliseconds)

Set a key's time to live in milliseconds (see <https://redis.io/commands/pexpire>)

`pexpireat`

$r->pexpireat(key, milliseconds-timestamp)

Set the expiration for a key as a UNIX timestamp specified in milliseconds (see <https://redis.io/commands/pexpireat>)

`pttl`

$r->pttl(key)

Get the time to live for a key in milliseconds (see <https://redis.io/commands/pttl>)

`randomkey`

$r->randomkey()

Return a random key from the keyspace (see <https://redis.io/commands/randomkey>)

`rename`

$r->rename(key, newkey)

Rename a key (see <https://redis.io/commands/rename>)

`renamenx`

$r->renamenx(key, newkey)

Rename a key, only if the new key does not exist (see <https://redis.io/commands/renamenx>)

`restore`

$r->restore(key, ttl, serialized-value)

Create a key using the provided serialized value, previously obtained using DUMP. (see <https://redis.io/commands/restore>)

`scan`

$r->scan(cursor, [MATCH pattern], [COUNT count])

Incrementally iterate the keys space (see <https://redis.io/commands/scan>)

`sort`

$r->sort(key, [BY pattern], [LIMIT offset count], [GET pattern [GET pattern ...]], [ASC|DESC], [ALPHA], [STORE destination])

Sort the elements in a list, set or sorted set (see <https://redis.io/commands/sort>)

`ttl`

$r->ttl(key)

Get the time to live for a key (see <https://redis.io/commands/ttl>)

`type`

$r->type(key)

Determine the type stored at key (see <https://redis.io/commands/type>)

💖 STRINGS 💖

okay so bestie, strings are literally the bread and butter of Redis, and these commands are your new besties for storing and messing with text and numbers. let's get into it. 🫶

append 🧵

$r->append(key, value)

appends value to whatever's already in key. it's giving "add to the end" energy. (see https://redis.io/commands/append)

bitcount 🔢

$r->bitcount(key, [start end])

counts how many bits are set to 1 in a string, no cap. (see https://redis.io/commands/bitcount)

bitop ⚡

$r->bitop(operation, destkey, key [key ...])

does bitwise operations between strings, periodt. (see https://redis.io/commands/bitop)

bitpos 🔍

$r->bitpos(key, bit, [start], [end])

finds the first bit that's either set or clear in a string, iykyk. (see https://redis.io/commands/bitpos)

blpop 🛑

$r->blpop(key [key ...], timeout)

removes and gets the first element in a list, or blocks until one shows up. it's giving main character energy waiting for its moment. (see https://redis.io/commands/blpop)

brpop 🛑

$r->brpop(key [key ...], timeout)

removes and gets the last element in a list, or blocks until one is available. patient queen. (see https://redis.io/commands/brpop)

brpoplpush 🔄

$r->brpoplpush(source, destination, timeout)

pops a value from a list, pushes it to another list, and returns it; or blocks until one is available. it's a whole journey. (see https://redis.io/commands/brpoplpush)

decr 📉

$r->decr(key)

decrements the integer value of a key by one. math but make it fashion. (see https://redis.io/commands/decr)

decrby 📉

$r->decrby(key, decrement)

decrements the integer value of a key by the number you give it. (see https://redis.io/commands/decrby)

get 🎁

$r->get(key)

gets the value of a key. simple as that. (see https://redis.io/commands/get)

getbit 🔹

$r->getbit(key, offset)

returns the bit value at offset in the string stored at key. (see https://redis.io/commands/getbit)

getrange ✂️

$r->getrange(key, start, end)

gets a substring of the string stored at a key. slice it. (see https://redis.io/commands/getrange)

getset 🔁

$r->getset(key, value)

sets the string value of a key and returns the old value. it's a glow-up with receipts. (see https://redis.io/commands/getset)

incr 📈

$r->incr(key)

increments the integer value of a key by one. +1 energy. (see https://redis.io/commands/incr)

incrby 📈

$r->incrby(key, increment)

increments the integer value of a key by the amount you specify. (see https://redis.io/commands/incrby)

incrbyfloat 🧮

$r->incrbyfloat(key, increment)

increments the float value of a key by the given amount. decimals are valid. (see https://redis.io/commands/incrbyfloat)

mget 📦

$r->mget(key [key ...])

gets the values of all the keys you list. multitasking queen. (see https://redis.io/commands/mget)

mset 📦

$r->mset(key value [key value ...])

sets multiple keys to multiple values. bulk vibes. (see https://redis.io/commands/mset)

msetnx 📦

$r->msetnx(key value [key value ...])

sets multiple keys to multiple values, but only if none of the keys already exist. no takebacks. (see https://redis.io/commands/msetnx)

psetex ⏳

$r->psetex(key, milliseconds, value)

sets the value and expiration in milliseconds of a key. precise. (see https://redis.io/commands/psetex)

set ✨

$r->set(key, value, ['EX',  seconds], ['PX', milliseconds], ['NX'|'XX'])

sets the string value of a key. the classic. example:

$r->set('key', 'test', 'EX', 60, 'NX')

(see https://redis.io/commands/set)

setbit 🔸

$r->setbit(key, offset, value)

sets or clears the bit at offset in the string value stored at key. (see https://redis.io/commands/setbit)

setex ⏳

$r->setex(key, seconds, value)

sets the value and expiration of a key. like a self-destructing message but for data. (see https://redis.io/commands/setex)

setnx 🥇

$r->setnx(key, value)

sets the value of a key, but only if the key doesn't already exist. first come, first served. (see https://redis.io/commands/setnx)

setrange ✏️

$r->setrange(key, offset, value)

overwrites part of a string at key starting at the specified offset. edit that text. (see https://redis.io/commands/setrange)

strlen 📏

$r->strlen(key)

gets the length of the value stored in a key. how long is it? very. (see https://redis.io/commands/strlen)

💜 HASHES 💜

okay so hashes are like little dictionaries, and these commands are how you talk to them. let's go. 🧚

hdel 🗑️

$r->hdel(key, field [field ...])

deletes one or more hash fields. bye felicia. (see https://redis.io/commands/hdel)

hexists ❓

$r->hexists(key, field)

determines if a hash field exists. does it exist? maybe. (see https://redis.io/commands/hexists)

hget 🔍

$r->hget(key, field)

gets the value of a hash field. (see https://redis.io/commands/hget)

hgetall 📚

$r->hgetall(key)

gets all the fields and values in a hash. the whole tea. (see https://redis.io/commands/hgetall)

hincrby 📈

$r->hincrby(key, field, increment)

increments the integer value of a hash field by the given number. (see https://redis.io/commands/hincrby)

hincrbyfloat 🧮

$r->hincrbyfloat(key, field, increment)

increments the float value of a hash field by the given amount. (see https://redis.io/commands/hincrbyfloat)

hkeys 🔑

$r->hkeys(key)

gets all the fields in a hash. (see https://redis.io/commands/hkeys)

hlen 📏

$r->hlen(key)

gets the number of fields in a hash. (see https://redis.io/commands/hlen)

hmget 📦

$r->hmget(key, field [field ...])

gets the values of all the given hash fields. (see https://redis.io/commands/hmget)

hmset 📦

$r->hmset(key, field value [field value ...])

sets multiple hash fields to multiple values. (see https://redis.io/commands/hmset)

hscan 🔄

$r->hscan(key, cursor, [MATCH pattern], [COUNT count])

incrementally iterates hash fields and associated values. (see https://redis.io/commands/hscan)

hset ✨

$r->hset(key, field, value)

sets the string value of a hash field. (see https://redis.io/commands/hset)

hsetnx 🥇

$r->hsetnx(key, field, value)

sets the value of a hash field, but only if the field doesn't already exist. (see https://redis.io/commands/hsetnx)

hvals 💎

$r->hvals(key)

gets all the values in a hash. (see https://redis.io/commands/hvals)

💙 SETS 💙

sets are unordered collections of unique things, and these commands are the moment. 💅

sadd 🎀

$r->sadd(key, member [member ...])

adds one or more members to a set. collect them all. (see https://redis.io/commands/sadd)

scard 🔢

$r->scard(key)

gets the number of members in a set. (see https://redis.io/commands/scard)

sdiff ➖

$r->sdiff(key [key ...])

subtracts multiple sets. math but make it sets. (see https://redis.io/commands/sdiff)

sdiffstore 💾

$r->sdiffstore(destination, key [key ...])

subtracts multiple sets and stores the resulting set in a key. (see https://redis.io/commands/sdiffstore)

sinter 🔗

$r->sinter(key [key ...])

intersects multiple sets. the overlap. (see https://redis.io/commands/sinter)

sinterstore 💾

$r->sinterstore(destination, key [key ...])

intersects multiple sets and stores the resulting set in a key. (see https://redis.io/commands/sinterstore)

sismember ❓

$r->sismember(key, member)

determines if a given value is a member of a set. are you in or out? (see https://redis.io/commands/sismember)

smembers 👯

$r->smembers(key)

gets all the members in a set. the whole squad. (see https://redis.io/commands/smembers)

smove 🚚

$r->smove(source, destination, member)

moves a member from one set to another. relocation. (see https://redis.io/commands/smove)

spop 🎲

$r->spop(key)

removes and returns a random member from a set. surprise! (see https://redis.io/commands/spop)

srandmember 🎲

$r->srandmember(key, [count])

gets one or multiple random members from a set. (see https://redis.io/commands/srandmember)

srem 🗑️

$r->srem(key, member [member ...])

removes one or more members from a set. (see https://redis.io/commands/srem)

sscan 🔄

$r->sscan(key, cursor, [MATCH pattern], [COUNT count])

incrementally iterates Set elements. (see https://redis.io/commands/sscan)

sunion ➕

$r->sunion(key [key ...])

adds multiple sets. (see https://redis.io/commands/sunion)

sunionstore 💾

$r->sunionstore(destination, key [key ...])

adds multiple sets and stores the resulting set in a key. (see https://redis.io/commands/sunionstore)

🍓 SORTED SETS 🍓

okay bestie, sorted sets are literally the moment. they keep everything in order by score and it's giving ✨organized✨. let's get into it 💅

`zadd`

$r->zadd(key, score member [score member ...])

Adds one or more members to a sorted set, or updates its score if it already exists. (see https://redis.io/commands/zadd) — no cap, this is the glow-up command 💖

`zcard`

$r->zcard(key)

Get the number of members in a sorted set. (see https://redis.io/commands/zcard) — it's giving headcount energy 👑

`zcount`

$r->zcount(key, min, max)

Count the members in a sorted set with scores within the given values. (see https://redis.io/commands/zcount) — lowkey a vibe check for scores 🔥

`zincrby`

$r->zincrby(key, increment, member)

Increment the score of a member in a sorted set. (see https://redis.io/commands/zincrby) — we love a little boost, fr fr 💅

`zinterstore`

$r->zinterstore(destination, numkeys, key [key ...], [WEIGHTS weight [weight ...]], [AGGREGATE SUM|MIN|MAX])

Intersect multiple sorted sets and store the resulting sorted set in a new key. (see https://redis.io/commands/zinterstore) — intersection slay ✨

`zlexcount`

$r->zlexcount(key, min, max)

Count the number of members in a sorted set between a given lexicographical range. (see https://redis.io/commands/zlexcount) — lexicographical? we love a fancy word 🎀

`zrange`

$r->zrange(key, start, stop, [WITHSCORES])

Return a range of members in a sorted set, by index. (see https://redis.io/commands/zrange) — range queen behavior 👑

`zrangebylex`

$r->zrangebylex(key, min, max, [LIMIT offset count])

Return a range of members in a sorted set, by lexicographical range. (see https://redis.io/commands/zrangebylex) — alphabetically iconic 💖

`zrangebyscore`

$r->zrangebyscore(key, min, max, [WITHSCORES], [LIMIT offset count])

Return a range of members in a sorted set, by score. (see https://redis.io/commands/zrangebyscore) — score-based and stunning 🔥

`zrank`

$r->zrank(key, member)

Determine the index of a member in a sorted set. (see https://redis.io/commands/zrank) — finding your place in the lineup, periodt 💅

`zrem`

$r->zrem(key, member [member ...])

Remove one or more members from a sorted set. (see https://redis.io/commands/zrem) — bye bestie, we won't miss you 😭

`zremrangebylex`

$r->zremrangebylex(key, min, max)

Remove all members in a sorted set between the given lexicographical range. (see https://redis.io/commands/zremrangebylex) — clearing out the alphabet soup 🧚

`zremrangebyrank`

$r->zremrangebyrank(key, start, stop)

Remove all members in a sorted set within the given indexes. (see https://redis.io/commands/zremrangebyrank) — index-based removal, no cap 🗑️

`zremrangebyscore`

$r->zremrangebyscore(key, min, max)

Remove all members in a sorted set within the given scores. (see https://redis.io/commands/zremrangebyscore) — score range cleanup, we love a tidy vibe ✨

`zrevrange`

$r->zrevrange(key, start, stop, [WITHSCORES])

Return a range of members in a sorted set, by index, with scores ordered from high to low. (see https://redis.io/commands/zrevrange) — reverse it, flip it, slay it 💅

`zrevrangebylex`

$r->zrevrangebylex(key, max, min, [LIMIT offset count])

Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings. (see https://redis.io/commands/zrevrangebylex) — lex order but backwards, iconic 🌈

`zrevrangebyscore`

$r->zrevrangebyscore(key, max, min, [WITHSCORES], [LIMIT offset count])

Return a range of members in a sorted set, by score, with scores ordered from high to low. (see https://redis.io/commands/zrevrangebyscore) — high score first, main character energy 👑

`zrevrank`

$r->zrevrank(key, member)

Determine the index of a member in a sorted set, with scores ordered from high to low. (see https://redis.io/commands/zrevrank) — rank reveal but reversed, obsessed 💖

`zscan`

$r->zscan(key, cursor, [MATCH pattern], [COUNT count])

Incrementally iterate sorted sets elements and associated scores. (see https://redis.io/commands/zscan) — slow and steady wins the scan 🐢

`zscore`

$r->zscore(key, member)

Get the score associated with the given member in a sorted set. (see https://redis.io/commands/zscore) — just the score, bestie, no extras 💅

`zunionstore`

$r->zunionstore(destination, numkeys, key [key ...], [WEIGHTS weight [weight ...]], [AGGREGATE SUM|MIN|MAX])

Add multiple sorted sets and store the resulting sorted set in a new key. (see https://redis.io/commands/zunionstore) — union? more like unite and slay ✨

🌈 HYPERLOGLOG 🌈

hyperloglog is giving "I count things but approximately" and honestly? same. let's go 🦋

`pfadd`

$r->pfadd(key, element [element ...])

Adds the specified elements to the specified HyperLogLog. (see https://redis.io/commands/pfadd) — adding elements, no biggie 💖

`pfcount`

$r->pfcount(key [key ...])

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s). (see https://redis.io/commands/pfcount) — approximate but make it fashion 💅

`pfmerge`

$r->pfmerge(destkey, sourcekey [sourcekey ...])

Merge N different HyperLogLogs into a single one. (see https://redis.io/commands/pfmerge) — merge them all, it's a crossover event 🔥

🌟 PUB/SUB 🌟

pub/sub is the group chat of Redis, fr fr. everyone gets the message. 💬

`pubsub`

$r->pubsub(subcommand, [argument [argument ...]])

Inspect the state of the Pub/Sub subsystem. (see https://redis.io/commands/pubsub) — peek behind the curtain, bestie 👀

💫 TRANSACTIONS 💫

transactions are giving "all or nothing" and we respect the commitment. periodt. 💅

`discard`

$r->discard()

Discard all commands issued after MULTI. (see https://redis.io/commands/discard) — nvm, forget I said anything 🙈

`exec`

$r->exec()

Execute all commands issued after MULTI. (see https://redis.io/commands/exec) — do it, no takebacks 🔥

`multi`

$r->multi()

Mark the start of a transaction block. (see https://redis.io/commands/multi) — starting a group project, but actually good 💖

`unwatch`

$r->unwatch()

Forget about all watched keys. (see https://redis.io/commands/unwatch) — not watching anymore, it's giving boundaries ✨

`watch`

$r->watch(key [key ...])

Watch the given keys to determine execution of the MULTI/EXEC block. (see https://redis.io/commands/watch) — keeping an eye on things, lowkey stalker energy 👀

🧚 SCRIPTING 🧚

lua scripts server-side? we love a little magic trick. abracadabra bestie. 🪄

`eval`

$r->eval(script, numkeys, key [key ...], arg [arg ...])

Execute a Lua script server side. (see https://redis.io/commands/eval) — run it, it's iconic 💅

`evalsha`

$r->evalsha(sha1, numkeys, key [key ...], arg [arg ...])

Execute a Lua script server side. (see https://redis.io/commands/evalsha) — same vibe, but with a sha1 glow-up ✨

`script_exists`

$r->script_exists(script [script ...])

Check existence of scripts in the script cache. (see https://redis.io/commands/script-exists) — do you exist? asking for a friend 🫶

`script_flush`

$r->script_flush()

Remove all the scripts from the script cache. (see https://redis.io/commands/script-flush) — clean slate, we love a reset 🧼

`script_kill`

$r->script_kill()

Kill the script currently in execution. (see https://redis.io/commands/script-kill) — dramatic exit, no cap 💀

`script_load`

$r->script_load(script)

Load the specified Lua script into the script cache. (see https://redis.io/commands/script-load) — upload that script, bestie 💖

🎀 CONNECTION 🎀

connection commands are the "hey bestie" of Redis. let's get connected. 🔌

`auth`

$r->auth(password)

Authenticate to the server. (see https://redis.io/commands/auth) — password check, slay 🔐

$r->auth(username, password)

Authenticate to the server using Redis 6.0+ ACL System. (see https://redis.io/commands/auth) — username and password? we love an upgrade 💅

`echo`

$r->echo(message)

Echo the given string. (see https://redis.io/commands/echo) — it's giving mirror mirror on the wall 🪞

`ping`

$r->ping()

Ping the server. (see https://redis.io/commands/ping) — are you there? it's me, bestie 📞

`quit`

$r->quit()

Close the connection. (see https://redis.io/commands/quit) — goodbye, it was fun, see you never 👋

`select`

$r->select(index)

Change the selected database for the current connection. (see https://redis.io/commands/select) — switching lanes, main character move 🚗

🖥️ SERVER 🖥️

okay bestie, this is the server-side menu — all the admin, config, list, and server-vibe commands. every single one is here, no skips, no cap. 💅

bgrewriteaof — $r->bgrewriteaof() — asynchronously rewrite the append-only file, like a lil glow-up for your AOF ✨ (see https://redis.io/commands/bgrewriteaof)
bgsave — $r->bgsave() — asynchronously save the dataset to disk, background vibes only 💾 (see https://redis.io/commands/bgsave)
client_getname — $r->client_getname() — get the current connection name, iykyk 🏷️ (see https://redis.io/commands/client-getname)
client_kill — $r->client_kill([ip:port], [ID client-id], [TYPE normal|slave|pubsub], [ADDR ip:port], [SKIPME yes/no]) — kill the connection of a client, bye bestie 👋 (see https://redis.io/commands/client-kill)
client_list — $r->client_list() — get the list of client connections (see https://redis.io/commands/client-list)
client_pause — $r->client_pause(timeout) — stop processing commands from clients for some time, like a timeout but for the whole server ⏸️ (see https://redis.io/commands/client-pause)
client_setname — $r->client_setname(connection-name) — set the current connection name (see https://redis.io/commands/client-setname)
cluster_slots — $r->cluster_slots() — get array of Cluster slot to node mappings (see https://redis.io/commands/cluster-slots)
command — $r->command() — get array of Redis command details (see https://redis.io/commands/command)
command_count — $r->command_count() — get total number of Redis commands (see https://redis.io/commands/command-count)
command_getkeys — $r->command_getkeys() — extract keys given a full Redis command (see https://redis.io/commands/command-getkeys)
command_info — $r->command_info(command-name [command-name ...]) — get array of specific Redis command details (see https://redis.io/commands/command-info)
config_get — $r->config_get(parameter) — get the value of a configuration parameter (see https://redis.io/commands/config-get)
config_resetstat — $r->config_resetstat() — reset the stats returned by INFO (see https://redis.io/commands/config-resetstat)
config_rewrite — $r->config_rewrite() — rewrite the configuration file with the in memory configuration (see https://redis.io/commands/config-rewrite)
config_set — $r->config_set(parameter, value) — set a configuration parameter to the given value (see https://redis.io/commands/config-set)
dbsize — $r->dbsize() — return the number of keys in the selected database (see https://redis.io/commands/dbsize)
debug_object — $r->debug_object(key) — get debugging information about a key (see https://redis.io/commands/debug-object)
debug_segfault — $r->debug_segfault() — make the server crash 💀 yes literally, it's a debug command, be careful bestie (see https://redis.io/commands/debug-segfault)
flushall — $r->flushall() — remove all keys from all databases, like a full reset but scary 😭 (see https://redis.io/commands/flushall)
flushdb — $r->flushdb() — remove all keys from the current database (see https://redis.io/commands/flushdb)
info — $r->info([section]) — get information and statistics about the server (see https://redis.io/commands/info)
lastsave — $r->lastsave() — get the UNIX time stamp of the last successful save to disk (see https://redis.io/commands/lastsave)
lindex — $r->lindex(key, index) — get an element from a list by its index (see https://redis.io/commands/lindex)
linsert — $r->linsert(key, BEFORE|AFTER, pivot, value) — insert an element before or after another element in a list (see https://redis.io/commands/linsert)
llen — $r->llen(key) — get the length of a list (see https://redis.io/commands/llen)
lpop — $r->lpop(key) — remove and get the first element in a list (see https://redis.io/commands/lpop)
lpush — $r->lpush(key, value [value ...]) — prepend one or multiple values to a list (see https://redis.io/commands/lpush)
lpushx — $r->lpushx(key, value) — prepend a value to a list, only if the list exists (see https://redis.io/commands/lpushx)
lrange — $r->lrange(key, start, stop) — get a range of elements from a list (see https://redis.io/commands/lrange)
lrem — $r->lrem(key, count, value) — remove elements from a list (see https://redis.io/commands/lrem)
lset — $r->lset(key, index, value) — set the value of an element in a list by its index (see https://redis.io/commands/lset)
ltrim — $r->ltrim(key, start, stop) — trim a list to the specified range (see https://redis.io/commands/ltrim)
monitor — $r->monitor() — listen for all requests received by the server in real time (see https://redis.io/commands/monitor)
role — $r->role() — return the role of the instance in the context of replication (see https://redis.io/commands/role)
rpop — $r->rpop(key) — remove and get the last element in a list (see https://redis.io/commands/rpop)
rpoplpush — $r->rpoplpush(source, destination) — remove the last element in a list, append it to another list and return it (see https://redis.io/commands/rpoplpush)
rpush — $r->rpush(key, value [value ...]) — append one or multiple values to a list (see https://redis.io/commands/rpush)
rpushx — $r->rpushx(key, value) — append a value to a list, only if the list exists (see https://redis.io/commands/rpushx)
save — $r->save() — synchronously save the dataset to disk (see https://redis.io/commands/save)
shutdown — $r->shutdown([NOSAVE], [SAVE]) — synchronously save the dataset to disk and then shut down the server (see https://redis.io/commands/shutdown)
slaveof — $r->slaveof(host, port) — make the server a slave of another instance, or promote it as master (see https://redis.io/commands/slaveof)
slowlog — $r->slowlog(subcommand, [argument]) — manages the Redis slow queries log (see https://redis.io/commands/slowlog)
sync — $r->sync() — internal command used for replication (see https://redis.io/commands/sync)
time — $r->time() — return the current server time (see https://redis.io/commands/time)

🫶 ACKNOWLEDGEMENTS 🫶

big love to the following people who contributed to this project (random order):

Aaron Crane (pipelining and AUTOLOAD caching support)
Dirk Vleugels
Flavio Poletti
Jeremy Zawodny
sunnavy at bestpractical.com
Thiago Berlitz Rondon
Ulrich Habel
Ivan Kruglov
Steffen Mueller <smueller@cpan.org>

👑 AUTHORS 👑

the masterminds behind this page:

Pedro Melo <melo@cpan.org>
Damien Krotkine <dams@cpan.org>

📜 COPYRIGHT AND LICENSE 📜

This is free software, licensed under:

The Artistic License 2.0 (GPL Compatible)

periodt. 💅

this page is Redis(3pm) from perl v5.36.0, dated 2023-01-14 — hope this helped bestie, go slay 💖✨

📦 where this page comes from

debian bookworm: libredis-perl 2:2.000-1 · Artistic-2.0
debian trixie: libredis-perl 2:2.000-1 · Artistic-2.0
ubuntu noble: libredis-perl 2:2.000-1 · Artistic-2.0
ubuntu resolute: libredis-perl 2:2.000-1 · Artistic-2.0
ubuntu stonking: libredis-perl 2:2.000-1 · Artistic-2.0
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

Redis(3pm)

💖 Redis(3pm) — the Perl binding for Redis, bestie edition 💖

✨ NAME ✨

🌸 VERSION 🌸

🎀 SYNOPSIS 🎀

🦋 DESCRIPTION 🦋

🌈 PIPELINING 🌈

🧚 ENCODING 🧚

🎀 CONSTRUCTOR 🎀

✨ new ✨

🖥️ "server"

🔁 "reconnect", "every"

🛡️ "conservative_reconnect"

⏱️ "cnx_timeout"

📡 "sentinels_cnx_timeout"

📖 "read_timeout"

📡📖 "sentinels_read_timeout"

✍️ "write_timeout"

📡✍️ "sentinels_write_timeout"

🔑 "password"

🎣 "on_connect"

🚫 "no_auto_connect_on_new"

🚫📋 "no_sentinels_list_update"

🏷️ "name"

🔒 "ssl"

🔏 "SSL_verify_mode"

🐛 "debug"

🔌 CONNECTION HANDLING 🔌

connect

quit

ping

📬 PIPELINE MANAGEMENT 📬

wait_all_responses

wait_one_response

💌 PUBLISH/SUBSCRIBE COMMANDS 💌

publish

subscribe

unsubscribe

psubscribe

punsubscribe

is_subscriber

wait_for_messages

🚨 IMPORTANT NOTES ON METHODS 🚨

methods that return multiple values

transaction-handling methods

exec

keys

hashes

eval

info

🗝️ KEYS 🗝️

del

dump

exists

expire

expireat

keys

migrate

move

object

persist

pexpire

pexpireat

pttl

randomkey

rename

renamenx

restore

scan

sort

ttl

type

💖 STRINGS 💖

append 🧵

bitcount 🔢

bitop ⚡

bitpos 🔍

blpop 🛑

brpop 🛑

brpoplpush 🔄

`publish`

`subscribe`

`unsubscribe`

`psubscribe`

`punsubscribe`

`is_subscriber`

`wait_for_messages`

`exec`

`keys`

`eval`

`info`

`del`

`dump`

`exists`

`expire`

`expireat`

`keys`

`migrate`

`move`

`object`

`persist`

`pexpire`

`pexpireat`

`pttl`

`randomkey`

`rename`

`renamenx`

`restore`

`scan`

`sort`

`ttl`

`type`

`zadd`

`zcard`

`zcount`

`zincrby`

`zinterstore`

`zlexcount`

`zrange`

`zrangebylex`

`zrangebyscore`

`zrank`

`zrem`

`zremrangebylex`

`zremrangebyrank`

`zremrangebyscore`

`zrevrange`

`zrevrangebylex`

`zrevrangebyscore`

`zrevrank`

`zscan`