Accessing keys and arguments in Redis - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to access the first key in a Redis Lua script.

Redis

local key1 = KEYS[[1]]

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

A1

B0

C2

Dkey

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as the index which causes an error.

Trying to access keys by name instead of index.

In Redis Lua scripts, keys are accessed starting at index 1, so KEYS[1] gets the first key.

2fill in blank

medium

Complete the code to access the second argument passed to the Redis Lua script.

Redis

local arg2 = ARGV[[1]]

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

A2

Barg

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as index which is invalid in Lua.

Confusing KEYS and ARGV tables.

ARGV holds the arguments passed to the script starting at index 1, so ARGV[2] is the second argument.

3fill in blank

hard

Fix the error in accessing the first key in the script.

Redis

local firstKey = KEYS[[1]]

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

Afirst

B0

Ckey1

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as index causing nil value.

Using string keys instead of numeric indices.

Lua tables start at 1, so KEYS[1] correctly accesses the first key.

4fill in blank

hard

Fill both blanks to get the third key and the first argument in the script.

Redis

local thirdKey = KEYS[[1]]
local firstArg = ARGV[[2]]

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

A3

B1

C2

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as index which is invalid.

Mixing up keys and arguments indices.

KEYS[3] accesses the third key, and ARGV[1] accesses the first argument.

5fill in blank

hard

Fill all three blanks to get the second key, the third argument, and the first key in the script.

Redis

local secondKey = KEYS[[1]]
local thirdArg = ARGV[[2]]
local firstKey = KEYS[[3]]

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

A1

B3

C2

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as index causing errors.

Confusing keys and arguments indices.

KEYS[2] is the second key, ARGV[3] is the third argument, and KEYS[1] is the first key.

Practice

1. In a Redis Lua script, which array is used to access the keys passed to the script?

easy

A. KEYS

B. ARGV

C. KEYSARGS

D. ARGS

Solution

1. Step 1: Understand Redis script inputs

   Redis Lua scripts receive keys and arguments separately.

2. Step 2: Identify the array for keys

   The keys are accessed using the KEYS array inside the script.

3. Final Answer:

   KEYS -> Option A

4. Quick Check:

   Keys = KEYS [OK]

Hint: Keys are always in KEYS array, arguments in ARGV [OK]

Common Mistakes:

• Confusing KEYS with ARGV
• Using ARGS instead of ARGV
• Assuming keys are in ARGV

2. Which of the following is the correct way to access the first argument (not key) inside a Redis Lua script?

easy

A. KEYS[1]

B. ARGV[0]

C. ARGV[1]

D. ARGS[1]

Solution

1. Step 1: Recall Lua array indexing

   Lua arrays start at 1, not 0.

2. Step 2: Identify argument array

   Arguments are accessed via ARGV array, so first argument is ARGV[1].

3. Final Answer:

   ARGV[1] -> Option C

4. Quick Check:

   First argument = ARGV[1] [OK]

Hint: Lua arrays start at 1, so first argument is ARGV[1] [OK]

Common Mistakes:

• Using zero-based index ARGV[0]
• Confusing KEYS with ARGV
• Using ARGS instead of ARGV

3. Consider this Redis Lua script snippet:

local key1 = KEYS[1]
local arg1 = ARGV[1]
return key1 .. '-' .. arg1

If the script is called with keys = ["user:1"] and arguments = ["active"], what is the returned result?

medium

A. "user:1-active"

B. "active-user:1"

C. "user:1active"

D. An error occurs

Solution

1. Step 1: Assign values from KEYS and ARGV

   key1 = "user:1", arg1 = "active" from the inputs.

2. Step 2: Concatenate with separator

   Return value is key1 .. '-' .. arg1 = "user:1-active".

3. Final Answer:

   "user:1-active" -> Option A

4. Quick Check:

   Concatenate KEYS[1] and ARGV[1] with '-' = "user:1-active" [OK]

Hint: Concatenate KEYS and ARGV with .. operator in Lua [OK]

Common Mistakes:

• Swapping KEYS and ARGV values
• Missing separator '-' in concatenation
• Using zero-based indexing

4. You wrote this Redis Lua script:

local key = KEYS[1]
local arg = ARGV[0]
return key .. arg

When running the script with one key and one argument, what will happen?

medium

A. It throws an error due to invalid index

B. It returns nil concatenated with key

C. It returns only the key

D. It returns concatenated key and argument

Solution

1. Step 1: Check Lua indexing rules

   Lua arrays start at 1, so ARGV[0] is invalid but returns nil.

2. Step 2: Understand behavior on invalid index

   Accessing ARGV[0] returns nil, concatenating key .. nil results in key .. "nil" or error depending on Lua version.

3. Final Answer:

   It returns nil concatenated with key -> Option B

4. Quick Check:

   Lua arrays start at 1, ARGV[0] returns nil, concatenation with nil results in string with 'nil' [OK]

Hint: Lua arrays start at 1, never use index 0 [OK]

Common Mistakes:

• Using zero-based index ARGV[0]
• Assuming ARGV[0] returns first argument
• Ignoring Lua indexing rules

5. You want to write a Redis Lua script that takes two keys and one argument. The script should return the value of the first key concatenated with the argument, then the value of the second key. Which is the correct way to access these inside the script?

hard

A. ARGV[1], KEYS[1], KEYS[2]

B. ARGV[0], KEYS[1], ARGV[1]

C. KEYS[0], ARGV[0], KEYS[1]

D. KEYS[1], ARGV[1], KEYS[2]

Solution

1. Step 1: Identify keys and argument positions

   Two keys are KEYS[1] and KEYS[2], one argument is ARGV[1].

2. Step 2: Access in correct order

   Access first key as KEYS[1], argument as ARGV[1], second key as KEYS[2].

3. Final Answer:

   KEYS[1], ARGV[1], KEYS[2] -> Option D

4. Quick Check:

   Keys in KEYS[], args in ARGV[], Lua index starts at 1 [OK]

Hint: Keys in KEYS[], args in ARGV[], index from 1 [OK]

Common Mistakes:

• Using zero-based indexes
• Mixing KEYS and ARGV order
• Using ARGV for keys