Jedis.jl

A lightweight Redis client, implemented in Julia.

Key Features

Links to detailed interfaces and documentation:

• Basic command execution
• Executing commands with a global client instance
• Pipelining
• Transactions
• Pub/Sub
• Redis locks
• Support for secured Redis connection (SSL/TLS)

Usage

Establishing a basic client connection:

client = Client(host="localhost", port=6379)

Establishing a secured client (SSL/TLS) connection:

ssl_config = get_ssl_config(ssl_certfile="redis.crt", ssl_keyfile="redis.key", ssl_ca_certs="ca.crt")
client = Client(ssl_config=ssl_config)

Setting and getting the global client:

set_global_client(client)
get_global_client()

Executing commands:

set("key", "value"; client=client)
get("key")  # uses global client by default
execute(["DEL", "key"], client)  # custom commands

Using pipelining to speed up queries:

# Normal
pipe = Pipeline()
set("key", "value"; client=pipe)
get("key"; client=pipe)
results = execute(pipe)

# Do-block
results = pipeline() do pipe
    lpush("example", 1, 2, 3, 4; client=pipe)
    lpop("example"; client=pipe)
    rpop("example"; client=pipe)
    lpop("example"; client=pipe)
end

Executing a group of commands atomically with MULTI/EXEC transactions:

# Normal
multi()
set("key", "value")
get("key")
results = exec()

# Do-block
results = multi_exec() do 
    set("key", "value")
    get("key")
    get("key")
end

Executing a MULTI/EXEC transaction within a pipeline:

results = pipeline() do pipe
    lpush("example", 1, 2, 3, 4; client=pipe)
    lpop("example"; client=pipe)
    rpop("example"; client=pipe)

    multi_exec(; client=pipe) do
        lpop("example"; client=pipe)
        rpop("example"; client=pipe)
    end

    lpop("example"; client=pipe)
end

Using Redis Pub/Sub (interfaces for subscribe and psubscribe are the same):

# Set up channels, publisher and subscriber clients
channels = ["first", "second"]
publisher = Client()
subscriber = Client()

# Begin the subscription
stop_fn(msg) = msg[end] == "close subscription";  # stop the subscription loop if the message matches
messages = []

@async subscribe(channels...; stop_fn=stop_fn, client=subscriber) do msg
    push!(messages, msg)
end  # Without @async this function will block, alternatively use Thread.@spawn

wait_until_subscribed(subscriber)
subscriber.is_subscribed  # outputs true
subscriber.subscriptions  # set of actively subscribed channels

# Publish to channels
publish("first", "hello"; client=publisher)
publish("second", "world"; client=publisher)

# Unsubscribing
unsubscribe("first"; client=subscriber)
wait_until_channel_unsubscribed(subscriber, "first")
subscriber.subscriptions
unsubscribe(; client=subscriber)  # unsubscribe from all channels
wait_until_unsubscribed(subscriber)
subscriber.is_subscribed  # outputs false
subscriber.subscriptions  # set of actively subscribed channels should be empty

Using redis locks for performing atomic operations:

@async redis_lock("example_lock") do
    sleep(3)  # Lock will exist for 3 seconds
end

while !isredislocked("example_lock")
    sleep(0.1)  # Ensure async lock is active before proceeding
end

redis_lock("example_lock") do
    println("This message will be delayed by 3 seconds!")  # Blocked by first lock
end