This project was created by a developer from Ukraine.

Russia has invaded Ukraine and already killed tens of thousands of civilians, with many more raped or tortured.

The death toll keeps climbing. It's a genocide. We need your help. Let's fight back against the Russian regime.

Support Ukraine


This project was created by a developer from Ukraine.

Russia has invaded Ukraine and already killed tens of thousands of civilians,

with many more raped or tortured. It's a genocide. We need your help.

Support Ukraine



A pure-Crystal implementation of the Redis protocol


  1. Add the dependency to your shard.yml:

        github: jgaskins/redis
  2. Run shards


require "redis"

redis = # Defaults to `localhost` port 6379

redis.set "foo", "bar"
redis.get "foo" # => "bar"

redis.incr "counter" # => 1
redis.incr "counter" # => 2
redis.decr "counter" # => 1

redis.del "foo", "counter" # => 2

Pipelined queries

To mitigate latency with multiple queries whose inputs and outputs are completely independent of each other, you can "pipeline" your queries by sending them all at once before reading them. To do this, you can use the pipeline method:

redis.pipeline do |pipe|
  pipe.incr "foo"
  pipe.set "bar", "baz"
  pipe.lpush "my-list", "my value"

The return value of pipeline will be an array containing the values of each of those calls in the order they were sent. So in this case, it might be [1, nil, 2] to match the return values of incr, set, and lpush, respectively.


The Redis MULTI command begins a transaction, so you can use the multi method to execute a transaction against the server:

redis.multi do |txn|
  txn.set "foo", "bar"
  txn.incr "baz"
  txn.lpush "my-list", "my value"

The transaction is automatically committed with EXEC at the end of the block. If an exception occurs within the block, the transaction will be rolled back with DISCARD before exiting the block.

You may also call txn.discard, which will effectively disable the transaction (all further methods called on the transaction do nothing), but will not exit the block. You will need to exit the block explicitly with break if there are operations within the block that cannot be rolled back, such as sending an email or sending a request to a third-party API.

The reason for this is that the only way to exit a containing block from an inner method in Crystal is to raise an exception, and this library chooses not to use exceptions for flow control.

Beyond localhost

To use a Redis server that isn't at localhost:6379, pass a URI to the client. For example, if you store it in your shell environment:

redis =["REDIS_URL"]))

# ... or ...

redis = Redis::Client.from_env("REDIS_URL")

To connect via SSL, make sure you use the rediss:// URL scheme. If your Redis server requires a password or uses a different database slot than 0, make sure you include them in the URL:

redis ="rediss://"))

Connection Pool

The Redis::Client maintains its own connection pool, so there is no need to run your own within your application. When you execute a command on the Redis::Client, it is automatically being executed against a connection. When you execute a pipeline or transaction with multi, all commands within that block will automatically be routed to the same connection.


Make sure you have a Redis or KeyDB server running locally on port 6379.


  1. Fork it (
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request


github statistic
  • 33
  • 7
  • 9
  • 5
  • 27 days ago
  • June 27, 2020

MIT License

Synced at

Mon, 27 Jun 2022 20:50:04 GMT