Add the following code to your project's shard.yml under:
to use in production
- OR -
development_dependencies to use in development
A pure-Crystal implementation of the Redis protocol
Add the dependency to your
dependencies: redis: github: jgaskins/redis
Note that this shard currently depends on a fork of
crystal-db for its connection pool. I'm in the process of getting those changes merged upstream so it can depend on the mainline implementation of that shard.
require "redis" redis = Redis::Client.new # 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
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
redis.pipeline do |pipe| pipe.incr "foo" pipe.set "bar", "baz" pipe.lpush "my-list", "my value" end
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
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" end
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.
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::Client.new(URI.parse(ENV["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 = Redis::Client.new(URI.parse("rediss://:firstname.lastname@example.org/3"))
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.
git checkout -b my-new-feature)
git commit -am 'Add some feature')
git push origin my-new-feature)