Why Lua scripts enable atomicity in Redis - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why are Lua scripts atomic in Redis?

In Redis, Lua scripts run atomically. What does this mean for commands inside a Lua script?

A Commands inside the script run one by one but can be interrupted by other clients.

B All commands inside the script run as a single, uninterrupted operation.

C Each command inside the script runs in a separate transaction.

D Lua scripts run asynchronously and may overlap with other commands.

💡 Hint

Think about what atomic means in the context of operations.

Atomic means the entire script runs without interruption, so no other commands can run in the middle.

❓ query_result

intermediate

Output of a Lua script modifying a key atomically

Given this Lua script run in Redis:

redis.call('SET', 'counter', 0)
for i = 1, 3 do
  redis.call('INCR', 'counter')
end
return redis.call('GET', 'counter')

What is the output after running this script?

A "1"

B "0"

C "3"

D nil

💡 Hint

The script increments the counter three times starting from zero.

The script sets 'counter' to 0, then increments it 3 times, so the final value is 3.

📝 Syntax

advanced

Identify the syntax error in this Lua script for Redis

Which option contains a syntax error that prevents the Lua script from running atomically in Redis?

for i = 1, 5 do
  redis.call('INCR', 'score')
end
return redis.call('GET', 'score')

A for i = 1, 5 do redis.call('INCR', 'score') end return redis.call('GET', 'score')

B )'erocs' ,'TEG'(llac.sider nruter dne )'erocs' ,'RCNI'(llac.sider od 5 ,1 = i rof

C or i = 1, 5 do redis.call('INCR', 'score') end return redis.call('GET', 'score')

D for i = 1, 5 redis.call('INCR', 'score') end return redis.call('GET', 'score')

💡 Hint

Check the for loop syntax carefully.

Option D is missing the 'do' keyword after the for loop declaration, causing a syntax error.

❓ optimization

advanced

Optimizing Lua script atomic operations in Redis

Which Lua script is the most efficient way to atomically increment two keys 'a' and 'b' by 1 in Redis?

A

local a = redis.call('INCR', 'a')
local b = redis.call('INCR', 'b')
return {a, b}

B

redis.call('INCR', 'a')
return redis.call('INCR', 'b')

C

redis.call('INCR', 'a')
redis.call('INCR', 'b')
return {redis.call('GET', 'a'), redis.call('GET', 'b')}

D

redis.call('INCRBY', 'a', 1)
redis.call('INCRBY', 'b', 1)
return {redis.call('GET', 'a'), redis.call('GET', 'b')}

💡 Hint

Consider minimizing calls and returning values directly.

Option A increments both keys and stores the results locally, then returns them, reducing extra calls.

🔧 Debug

expert

Why does this Lua script cause a runtime error in Redis?

Consider this Lua script:

local val = redis.call('GET', 'missing_key')
return val + 1

What error will Redis raise when running this script and why?

A Attempt to perform arithmetic on a nil value because 'missing_key' does not exist.

B Syntax error due to missing parentheses in redis.call.

C Redis returns nil without error because missing keys are allowed.

D Type error because redis.call returns a table, not a string.

💡 Hint

Think about what happens when you try to add a number to nil in Lua.

When 'missing_key' does not exist, redis.call returns nil. Adding 1 to nil causes a runtime error.

Practice

1. Why do Lua scripts in Redis ensure atomicity?

easy

A. Because they run as a single, uninterruptible operation

B. Because they use multiple threads simultaneously

C. Because they store data in separate databases

D. Because they execute commands randomly

Solution

1. Step 1: Understand Lua script execution in Redis

   Lua scripts run all commands inside them as one single operation without interruption.

2. Step 2: Connect atomicity to uninterrupted execution

   This uninterrupted execution means no other commands can interfere, ensuring atomicity.

3. Final Answer:

   Because they run as a single, uninterruptible operation -> Option A

4. Quick Check:

   Atomicity = single uninterruptible operation [OK]

Hint: Atomicity means no interruptions during script run [OK]

Common Mistakes:

• Thinking Lua scripts run in multiple threads
• Believing Lua scripts split commands across databases
• Assuming commands execute randomly

2. Which of the following is the correct way to start a Lua script in Redis?

easy

A. EVAL 'return redis.call("GET", "key")' 1 key

B. RUN 'return redis.call("GET", "key")' 1 key

C. EXECUTE 'return redis.call("GET", "key")' 1 key

D. SCRIPT 'return redis.call("GET", "key")' 1 key

Solution

1. Step 1: Identify Redis command to run Lua scripts

   Redis uses the EVAL command to run Lua scripts.

2. Step 2: Check syntax correctness

   EVAL 'script' number_of_keys keys... is the correct syntax.

3. Final Answer:

   EVAL 'return redis.call("GET", "key")' 1 key -> Option A

4. Quick Check:

   Use EVAL to run Lua scripts [OK]

Hint: Lua scripts start with EVAL command in Redis [OK]

Common Mistakes:

• Using RUN instead of EVAL
• Using EXECUTE or SCRIPT commands incorrectly
• Missing the number of keys argument

3. What will be the output of this Lua script run in Redis?

EVAL "return redis.call('INCR', KEYS[1])" 1 counter

Assuming the key 'counter' has value 5 before running.

medium

A. nil

B. 5

C. Error

D. 6

Solution

1. Step 1: Understand the INCR command effect

   INCR increases the integer value stored at the key by 1 and returns the new value.

2. Step 2: Apply INCR to current value 5

   Incrementing 5 by 1 results in 6, which is returned by the script.

3. Final Answer:

   6 -> Option D

4. Quick Check:

   INCR(5) = 6 [OK]

Hint: INCR returns incremented value, not original [OK]

Common Mistakes:

• Thinking INCR returns old value
• Expecting nil if key exists
• Assuming script causes error

4. You wrote this Lua script for Redis:

EVAL "redis.call('SET', KEYS[1], ARGV[1])" 1 mykey newvalue

But it does not return any value. What is the problem?

medium

A. Lua scripts cannot use redis.call

B. Wrong number of keys argument

C. Missing 'return' before redis.call

D. Incorrect key name format

Solution

1. Step 1: Check Lua script return statement

   Lua scripts must return a value explicitly to get output from EVAL.

2. Step 2: Identify missing return

   The script calls redis.call but does not return its result, so output is nil.

3. Final Answer:

   Missing 'return' before redis.call -> Option C

4. Quick Check:

   Lua scripts need 'return' for output [OK]

Hint: Always use 'return' to get Lua script output [OK]

Common Mistakes:

• Assuming redis.call auto-returns value
• Incorrect keys count causing error
• Believing redis.call is disallowed

5. You want to increment two counters atomically in Redis using Lua. Which script ensures both increments happen together without interference?

EVAL "redis.call('INCR', KEYS[1]); redis.call('INCR', KEYS[2]); return {redis.call('GET', KEYS[1]), redis.call('GET', KEYS[2])}" 2 counter1 counter2

hard

A. This script is not atomic because it uses multiple redis.call commands

B. This script is atomic because Lua scripts run without interruption

C. This script is atomic only if wrapped in MULTI/EXEC

D. This script is not atomic because it returns multiple values

Solution

1. Step 1: Understand Lua script atomicity in Redis

   All commands inside a Lua script run as one atomic operation, no matter how many redis.call commands are used.

2. Step 2: Confirm script increments both counters atomically

   Both INCR commands run together without interruption, ensuring atomicity.

3. Final Answer:

   This script is atomic because Lua scripts run without interruption -> Option B

4. Quick Check:

   Multiple redis.call in Lua script = atomic [OK]

Hint: Multiple commands in Lua script run atomically [OK]

Common Mistakes:

• Thinking multiple redis.call break atomicity
• Believing MULTI/EXEC needed inside Lua
• Assuming returning multiple values breaks atomicity