Transactions vs Lua scripts in Redis - Practice Questions

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this Redis transaction?

Consider the following Redis transaction commands executed sequentially:

1. MULTI
2. SET key1 100
3. INCR key1
4. EXEC

What will be the value of key1 after the transaction completes?

Redis

MULTI
SET key1 100
INCR key1
EXEC

A Error: key1 is not an integer

B 1

C 100

D 101

💡 Hint

Remember that Redis transactions queue commands and execute them atomically.

The transaction sets key1 to '100' and then increments it by 1, resulting in 101.

❓ query_result

intermediate

What does this Lua script return in Redis?

Given this Lua script run with EVAL:

local val = redis.call('GET', KEYS[1])
if val == nil then
redis.call('SET', KEYS[1], ARGV[1])
return ARGV[1]
else
return val
end

Assuming key1 does not exist before running, what is the output of the script when called with ARGV[1] = 'hello'?

Redis

local val = redis.call('GET', KEYS[1])
if val == nil then
  redis.call('SET', KEYS[1], ARGV[1])
  return ARGV[1]
else
  return val
end

A nil

B Error: key does not exist

C "hello"

D false

💡 Hint

Lua scripts in Redis return strings or nil, and redis.call returns nil if key does not exist.

Since key1 does not exist, redis.call('GET', KEYS[1]) returns nil, so the script sets key1 to 'hello' and returns 'hello'.

🧠 Conceptual

advanced

Why might Lua scripts be preferred over Redis transactions?

Which of the following is the best reason to use Lua scripts instead of Redis transactions?

A Lua scripts cannot access Redis keys, so they are safer.

B Lua scripts guarantee atomic execution and can perform complex logic in one call.

C Transactions are faster because they do not support atomicity.

D Transactions allow rollback on error, Lua scripts do not.

💡 Hint

Think about atomicity and complexity of operations.

Lua scripts run atomically and can execute complex logic in one call, unlike transactions which queue commands but cannot perform conditional logic inside.

🔧 Debug

advanced

Identify the error in this Redis transaction usage

A developer writes this Redis transaction:

1. MULTI
2. GET key1
3. INCR key1
4. EXEC

But the GET command returns the old value of key1, not the incremented one. Why?

A Commands in a transaction are queued and executed only after EXEC, so GET sees the old value.

B GET command is invalid inside MULTI block.

C INCR does not change the value immediately, so GET returns nil.

D EXEC discards all commands except the last one.

💡 Hint

Think about when commands inside MULTI are executed.

Inside MULTI, commands are queued but not executed until EXEC. So GET returns the old value because it is queued, not executed immediately.

❓ optimization

expert

Optimizing atomic updates: Lua script vs transaction

You want to atomically increment a counter only if it is less than 10. Which approach is more efficient and why?

Options:
1. Use a Redis transaction with WATCH, GET, INCR, and EXEC.
2. Use a Lua script that checks the value and increments if less than 10.

Choose the best option.

A Lua script is more efficient because it runs atomically on the server without retries.

B Neither is efficient; use client-side locking instead.

C Both are equally efficient because Redis handles atomicity internally.

D Transaction with WATCH is more efficient because it retries automatically.

💡 Hint

Consider network round trips and atomicity guarantees.

Lua scripts run atomically on the server and avoid the overhead of retries and multiple round trips required by WATCH transactions.