Why Lua scripts enable atomicity in Redis - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start a Lua script in Redis that runs atomically.

Redis

[1] "return redis.call('SET', 'key', 'value')" 0

Drag options to blanks, or click blank then click option'

AEVAL

BEXEC

CCALL

DMULTI

Attempts:

3 left

💡 Hint

Common Mistakes

Using MULTI or EXEC instead of EVAL for Lua scripts.

The EVAL command runs Lua scripts atomically in Redis.

2fill in blank

medium

Complete the code to return a value from a Lua script in Redis.

Redis

return redis.call([1], 'GET', 'key')

Drag options to blanks, or click blank then click option'

AEXISTS

BSET

CDEL

DGET

Attempts:

3 left

💡 Hint

Common Mistakes

Using SET instead of GET to retrieve a value.

The GET command retrieves the value of a key in Redis.

3fill in blank

hard

Fix the error in the Lua script to ensure atomic execution.

Redis

redis.call('SET', 'counter', redis.call([1], 'INCR', 'counter'))

Drag options to blanks, or click blank then click option'

AGET

BINCR

CDEL

DSET

Attempts:

3 left

💡 Hint

Common Mistakes

Using GET or SET instead of INCR for incrementing.

The INCR command increments a counter atomically in Redis.

4fill in blank

hard

Fill both blanks to create a Lua script that atomically checks and sets a key.

Redis

if redis.call([1], 'EXISTS', 'lock') == 0 then
  redis.call([2], 'SET', 'lock', '1')
end

Drag options to blanks, or click blank then click option'

AEXISTS

BSET

CGET

DDEL

Attempts:

3 left

💡 Hint

Common Mistakes

Using GET instead of EXISTS to check key presence.

The script checks if 'lock' exists and sets it if not, all atomically.

5fill in blank

hard

Fill all three blanks to write a Lua script that atomically increments a counter only if it exists.

Redis

if redis.call([1], 'EXISTS', 'counter') == 1 then
  return redis.call([2], 'INCR', 'counter')
else
  return redis.call([3], 'SET', 'counter', '1')
end

Drag options to blanks, or click blank then click option'

AEXISTS

BINCR

CSET

DDEL

Attempts:

3 left

💡 Hint

Common Mistakes

Using DEL instead of SET to initialize the counter.

This script checks if 'counter' exists, increments it if yes, or sets it to 1 if no, all atomically.

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