EVAL command for Lua execution in Redis - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the Redis EVAL command do?

It runs a Lua script directly on the Redis server, allowing you to execute multiple commands atomically and efficiently.

beginner

How do you specify keys and arguments when using the EVAL command?

You provide the Lua script, then the number of keys, followed by the keys themselves, and then the additional arguments accessible inside the script.

beginner

In a Lua script run by EVAL, how do you access the keys and arguments passed from Redis?

Keys are accessed using the KEYS table (e.g., KEYS[1]), and arguments are accessed using the ARGV table (e.g., ARGV[1]).

intermediate

Why is using EVAL with Lua scripts beneficial compared to multiple Redis commands?

Because the script runs atomically on the server, it avoids race conditions and reduces network overhead by combining multiple commands into one.

intermediate

What happens if a Lua script executed by EVAL tries to run a command that is not allowed or fails?

The entire script execution is stopped and rolled back, and Redis returns an error to the client.

What is the correct order of arguments for the Redis EVAL command?

A Keys, script, number of keys, arguments

B Number of keys, script, keys, arguments

C Script, number of keys, keys, arguments

D Arguments, keys, script, number of keys

The EVAL command syntax is: EVAL script numkeys key [key ...] arg [arg ...].

Inside a Lua script run by EVAL, how do you access the first key passed to the script?

A ARGV[1]

B KEYS[1]

C KEYS[0]

D ARGV[0]

Keys are accessed via the KEYS table starting at index 1.

What is one main advantage of using EVAL with Lua scripts in Redis?

A It reduces network round trips by running multiple commands atomically on the server.

B It allows running scripts on the client side.

C It automatically backs up your data.

D It speeds up Redis startup time.

Running scripts atomically on the server reduces network overhead and avoids race conditions.

If a Lua script executed by EVAL fails, what happens?

A The script continues running ignoring errors.

B The script output is saved partially.

C Redis restarts automatically.

D The script execution stops and Redis returns an error.

Redis stops the script and returns an error if any command inside fails.

Which of these is NOT a valid use of the EVAL command?

A Running Lua scripts on the client machine.

B Accessing keys and arguments inside Lua script.

C Running multiple Redis commands atomically.

D Reducing network round trips.

EVAL runs Lua scripts on the Redis server, not on the client.

Explain how the Redis EVAL command works and how you pass keys and arguments to the Lua script.

Think about how you tell the script which keys and extra data to use.

Describe the benefits of using Lua scripts with the EVAL command in Redis.

Consider what problems happen when sending many commands separately.

Practice

1. What is the main purpose of the EVAL command in Redis?

easy

A. To run Lua scripts inside Redis for atomic operations

B. To execute SQL queries on Redis data

C. To backup Redis data to a file

D. To create new Redis databases

Solution

1. Step 1: Understand Redis scripting

   Redis uses Lua scripts to perform complex or multiple operations atomically.

2. Step 2: Identify EVAL command role

   The EVAL command runs Lua scripts inside Redis, ensuring atomicity and reducing network calls.

3. Final Answer:

   To run Lua scripts inside Redis for atomic operations -> Option A

4. Quick Check:

   EVAL runs Lua scripts = D [OK]

Hint: EVAL runs Lua scripts atomically inside Redis [OK]

Common Mistakes:

• Confusing EVAL with SQL execution
• Thinking EVAL backs up data
• Assuming EVAL creates databases

2. Which of the following is the correct syntax to run a Lua script with EVAL in Redis?

easy

A. EVAL script numkeys key [key ...] arg [arg ...]

B. EVAL numkeys script key [key ...] arg [arg ...]

C. EVAL script key numkeys arg [arg ...]

D. EVAL script arg numkeys key [key ...]

Solution

1. Step 1: Recall EVAL syntax

   The correct syntax is EVAL script numkeys key [key ...] arg [arg ...], where numkeys tells how many keys follow.

2. Step 2: Match options

   Only EVAL script numkeys key [key ...] arg [arg ...] matches this exact order and structure.

3. Final Answer:

   EVAL script numkeys key [key ...] arg [arg ...] -> Option A

4. Quick Check:

   Script, numkeys, keys, args order = A [OK]

Hint: Remember: script, numkeys, keys, then args in EVAL [OK]

Common Mistakes:

• Placing numkeys after keys or args
• Mixing order of keys and args
• Omitting numkeys parameter

3. Given the Lua script return redis.call('GET', KEYS[1]) and the command EVAL script 1 mykey, what will Redis return if mykey holds the value 'hello'?

medium

A. An error because arguments are missing

B. nil

C. 'hello'

D. The string 'mykey'

Solution

1. Step 1: Understand the Lua script

   The script calls redis.call('GET', KEYS[1]), which fetches the value of the first key passed.

2. Step 2: Analyze the command

   The command passes 1 key: mykey. If mykey holds 'hello', the script returns 'hello'.

3. Final Answer:

   'hello' -> Option C

4. Quick Check:

   GET mykey = 'hello' [OK]

Hint: Lua script returns value of first key passed [OK]

Common Mistakes:

• Confusing keys and args
• Expecting key name instead of value
• Assuming nil if key exists

4. What is wrong with this Redis command? EVAL 'return redis.call('GET', KEYS[1])' 1 mykey

medium

A. Missing number of keys argument

B. The Lua script string uses conflicting single quotes causing syntax error

C. Keys and args are swapped

D. The command is correct and will run successfully

Solution

1. Step 1: Inspect Lua script quoting

   The Lua script is enclosed in single quotes, but inside it also uses single quotes for 'GET', causing quote conflict.

2. Step 2: Identify syntax error

   This causes a syntax error because the shell or Redis cannot parse the string properly.

3. Final Answer:

   The Lua script string uses conflicting single quotes causing syntax error -> Option B

4. Quick Check:

   Quote conflict in script string = A [OK]

Hint: Use different quotes or escape inner quotes in Lua script [OK]

Common Mistakes:

• Ignoring quote conflicts
• Forgetting to escape inner quotes
• Miscounting number of keys

5. You want to atomically increment a Redis key counter by a value passed as an argument using EVAL. Which Lua script and command correctly achieve this?

hard

A. Script: return redis.call('INCRBY', ARGV[1], KEYS[1])Command: EVAL script 1 counter 5

B. Script: return redis.call('INCRBY', KEYS[1], ARGV[1])Command: EVAL script 2 counter 5

C. Script: return redis.call('INCRBY', KEYS[1], ARGV[1])Command: EVAL script 0 counter 5

D. Script: return redis.call('INCRBY', KEYS[1], ARGV[1])Command: EVAL script 1 counter 5

Solution

1. Step 1: Understand INCRBY usage in Lua script

   The command redis.call('INCRBY', KEYS[1], ARGV[1]) increments the key by the argument value.

2. Step 2: Check command arguments

   Passing 1 as number of keys, then counter as key, and 5 as argument matches the script.

3. Final Answer:

   Script: return redis.call('INCRBY', KEYS[1], ARGV[1]) and Command: EVAL script 1 counter 5 -> Option D

4. Quick Check:

   INCRBY key arg with correct keys count = B [OK]

Hint: Keys count must match keys passed; args follow keys [OK]

Common Mistakes:

• Swapping keys and args order
• Incorrect number of keys argument
• Using zero keys when keys are needed