EVALSHA for cached scripts in Redis - Step-by-Step Execution

Concept Flow - EVALSHA for cached scripts

Write Lua script

↓

Load script with SCRIPT LOAD

↓

Get SHA1 hash of script

↓

Run script with EVALSHA using SHA1

↓

If SHA1 not found -> Error

↓

Optionally reload script and retry

You write a Lua script, load it into Redis to get a SHA1 hash, then run it using EVALSHA with that hash. If Redis doesn't have the script cached, you get an error and can reload it.

Execution Sample

Redis

SCRIPT LOAD "return redis.call('GET', KEYS[1])"
EVALSHA <sha1> 1 mykey

Load a Lua script that gets a key's value, then run it using its SHA1 hash.

Execution Table

Step	Command	Input	Action	Output/Result
1	SCRIPT LOAD	"return redis.call('GET', KEYS[1])"	Load script into Redis cache	Returns SHA1 hash: abc123...
2	EVALSHA	abc123... 1 mykey	Run cached script with SHA1	Returns value of 'mykey' if exists
3	EVALSHA	wrongsha 1 mykey	Try running with unknown SHA1	Error: NOSCRIPT No matching script. Please use EVAL.
4	SCRIPT LOAD	"return redis.call('GET', KEYS[1])"	Reload script after error	Returns SHA1 hash: abc123...
5	EVALSHA	abc123... 1 mykey	Run script again after reload	Returns value of 'mykey'

💡 Execution stops when script runs successfully or error occurs due to missing SHA1.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5
SHA1	null	abc123...	abc123...	wrongsha	abc123...	abc123...
Script Cached?	false	true	true	false	true	true
Script Result	null	null	value of mykey or nil	Error NOSCRIPT	null	value of mykey or nil

Key Moments - 2 Insights

Why do we get an error when using EVALSHA with a SHA1 that Redis doesn't know?

Because Redis only runs scripts it has cached. If the SHA1 is unknown, Redis returns a NOSCRIPT error as shown in step 3 of the execution_table.

What does SCRIPT LOAD do and why is it important before EVALSHA?

SCRIPT LOAD stores the Lua script in Redis and returns its SHA1 hash. This hash is needed to run the script with EVALSHA, as shown in step 1 and 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output of SCRIPT LOAD in step 1?

A Returns the SHA1 hash of the script

B Returns the value of 'mykey'

C Returns an error NOSCRIPT

D Returns null

💡 Hint

Check the 'Output/Result' column in step 1 of the execution_table

At which step does Redis return an error because the SHA1 is unknown?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for the 'Error: NOSCRIPT' message in the execution_table

If you skip SCRIPT LOAD and run EVALSHA with a random SHA1, what happens?

A Script runs successfully

B Redis returns NOSCRIPT error

C Redis loads the script automatically

D Redis returns null

💡 Hint

Refer to step 3 in the execution_table where unknown SHA1 causes error

Concept Snapshot

EVALSHA runs a cached Lua script by its SHA1 hash.
Use SCRIPT LOAD to cache script and get SHA1.
If SHA1 unknown, Redis returns NOSCRIPT error.
Reload script with SCRIPT LOAD before retrying EVALSHA.
This improves performance by avoiding sending full script each time.

Full Transcript

This visual execution shows how Redis runs Lua scripts using EVALSHA. First, you write a Lua script and load it into Redis with SCRIPT LOAD. This returns a SHA1 hash representing the script. You then run the script by calling EVALSHA with that SHA1 and the keys/arguments. If Redis does not have the script cached (unknown SHA1), it returns a NOSCRIPT error. You must reload the script with SCRIPT LOAD to cache it again before retrying EVALSHA. The execution table traces these steps, showing the SHA1 variable, caching state, and results. Key moments clarify why the NOSCRIPT error happens and the role of SCRIPT LOAD. The quiz tests understanding of these steps and error conditions. This method improves efficiency by sending only the SHA1 hash after caching the script once.

Practice

1. What does the Redis command EVALSHA primarily do?

easy

A. Uploads a new Lua script to Redis cache

B. Deletes a script from the cache by its SHA1 hash

C. Lists all cached scripts by their SHA1 hashes

D. Runs a cached Lua script using its SHA1 hash

Solution

1. Step 1: Understand the purpose of EVALSHA

   EVALSHA runs a Lua script already stored in Redis cache using its SHA1 hash instead of sending the full script text.

2. Step 2: Compare with other script commands

   Other commands like SCRIPT LOAD upload scripts, SCRIPT FLUSH deletes scripts, but EVALSHA executes cached scripts.

3. Final Answer:

   Runs a cached Lua script using its SHA1 hash -> Option D

4. Quick Check:

   EVALSHA = run cached script [OK]

Hint: EVALSHA runs scripts by hash, not by full text [OK]

Common Mistakes:

• Confusing EVALSHA with SCRIPT LOAD
• Thinking EVALSHA deletes scripts
• Assuming EVALSHA lists scripts

2. Which of the following is the correct syntax for using EVALSHA in Redis?

easy

A. EVALSHA <numkeys> <sha1> [key1 key2 ...] [arg1 arg2 ...]

B. EVALSHA <sha1> <numkeys> [key1 key2 ...] [arg1 arg2 ...]

C. EVALSHA <sha1> [key1 key2 ...] <numkeys> [arg1 arg2 ...]

D. EVALSHA <script> <numkeys> [key1 key2 ...] [arg1 arg2 ...]

Solution

1. Step 1: Recall EVALSHA syntax

   The correct syntax is: EVALSHA followed by the SHA1 hash, then the number of keys, then the keys, then the arguments.

2. Step 2: Check option formats

   EVALSHA <sha1> <numkeys> [key1 key2 ...] [arg1 arg2 ...] matches the correct order. Options A, B, and C have wrong order or use script text instead of SHA1.

3. Final Answer:

   EVALSHA <sha1> <numkeys> [key1 key2 ...] [arg1 arg2 ...] -> Option B

4. Quick Check:

   Syntax = EVALSHA sha1 numkeys keys args [OK]

Hint: SHA1 hash comes first, then number of keys [OK]

Common Mistakes:

• Putting script text instead of SHA1 hash
• Mixing order of numkeys and keys
• Omitting number of keys

3. Given the following Redis commands executed in order:

127.0.0.1:6379> SCRIPT LOAD "return {KEYS[1],ARGV[1]}"
"a1b2c3d4e5f6g7h8i9j0"
127.0.0.1:6379> EVALSHA a1b2c3d4e5f6g7h8i9j0 1 mykey myarg

What will be the output of the EVALSHA command?

medium

A. ["mykey", "myarg"]

B. ["myarg", "mykey"]

C. Error: NOSCRIPT No matching script

D. ["a1b2c3d4e5f6g7h8i9j0", "myarg"]

Solution

1. Step 1: Understand SCRIPT LOAD output

   SCRIPT LOAD returns the SHA1 hash of the script, here "a1b2c3d4e5f6g7h8i9j0".

2. Step 2: Analyze EVALSHA call

   EVALSHA runs the cached script with 1 key: "mykey" and 1 argument: "myarg". The script returns {KEYS[1], ARGV[1]} so output is ["mykey", "myarg"].

3. Final Answer:

   ["mykey", "myarg"] -> Option A

4. Quick Check:

   Return keys[1], argv[1] = [mykey, myarg] [OK]

Hint: SCRIPT LOAD returns SHA1; EVALSHA uses keys then args [OK]

Common Mistakes:

• Confusing keys and args order
• Expecting error without loading script
• Using script text instead of SHA1

4. You run the command EVALSHA deadbeef 2 key1 key2 arg1 but get the error NOSCRIPT No matching script. What is the most likely cause?

medium

A. The number of keys argument should be 1, not 2

B. You provided too many keys for the script

C. The SHA1 hash 'deadbeef' is not loaded in Redis script cache

D. The script syntax is invalid

Solution

1. Step 1: Understand NOSCRIPT error meaning

   This error means Redis does not have a cached script matching the given SHA1 hash.

2. Step 2: Check command usage

   Since the hash 'deadbeef' is not loaded, Redis cannot run the script. Number of keys or syntax errors cause different errors.

3. Final Answer:

   The SHA1 hash 'deadbeef' is not loaded in Redis script cache -> Option C

4. Quick Check:

   NOSCRIPT = missing cached script [OK]

Hint: NOSCRIPT means script hash not cached yet [OK]

Common Mistakes:

• Assuming wrong number of keys causes NOSCRIPT
• Thinking syntax error causes NOSCRIPT
• Ignoring that script must be loaded first

5. You want to optimize a Redis Lua script execution by caching it. Which sequence correctly uses SCRIPT LOAD and EVALSHA to run the script multiple times with different keys and arguments?

hard

A. Load script once with SCRIPT LOAD, save SHA1, then call EVALSHA with SHA1, numkeys, keys, args each time

B. Call EVALSHA with script text each time, no need to load script

C. Use SCRIPT FLUSH before every EVALSHA to clear cache

D. Call EVALSHA with SHA1 but always set numkeys to 0

Solution

1. Step 1: Understand caching workflow

   First, SCRIPT LOAD uploads the script and returns its SHA1 hash. This hash is saved for reuse.

2. Step 2: Use EVALSHA for repeated execution

   Use EVALSHA with the saved SHA1, specifying number of keys, keys, and arguments to run the script efficiently multiple times.

3. Final Answer:

   Load script once with SCRIPT LOAD, save SHA1, then call EVALSHA with SHA1, numkeys, keys, args each time -> Option A

4. Quick Check:

   Load once, run many times with EVALSHA [OK]

Hint: Load script once, then run with EVALSHA and SHA1 [OK]

Common Mistakes:

• Calling EVALSHA with script text instead of SHA1
• Flushing scripts before every run
• Setting numkeys incorrectly