MULTI command to start in Redis - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output after starting a transaction with MULTI?

You run the command MULTI in Redis to start a transaction. What is the immediate output you receive?

Redis

MULTI

A :1

B +OK

C -ERR wrong number of arguments for 'multi' command

D $-1

💡 Hint

Think about what Redis replies when a command is accepted successfully.

The MULTI command replies with +OK to indicate the transaction block has started successfully.

🧠 Conceptual

intermediate

What happens to commands after MULTI is called?

After you run MULTI, what happens to the commands you send before calling EXEC?

A Commands are queued and not executed immediately.

B Commands execute immediately and their results are returned.

C Commands are discarded until EXEC is called.

D Commands cause an error until EXEC is called.

💡 Hint

Think about how transactions work in Redis.

After MULTI, commands are queued and only executed when EXEC is called.

📝 Syntax

advanced

Which command sequence correctly starts and executes a transaction?

Choose the correct sequence of Redis commands to start a transaction, set a key, and execute the transaction.

A

MULTI
SET key1 value1
EXEC

B

EXEC
MULTI
SET key1 value1

C

SET key1 value1
MULTI
EXEC

D

MULTI
EXEC
SET key1 value1

💡 Hint

MULTI must come before queuing commands, and EXEC must come last.

The correct order is to start with MULTI, queue commands, then call EXEC to run them.

🔧 Debug

advanced

Why does this transaction fail to execute commands?

You run these commands: MULTI EXEC SET key1 value1 What is the problem?

A MULTI command was not recognized.

B EXEC must be called before MULTI.

C SET command syntax is incorrect.

D SET command is sent after EXEC, so it is not queued or executed in the transaction.

💡 Hint

Consider the order commands must be sent in a transaction.

Commands must be queued between MULTI and EXEC. Here, SET is after EXEC, so it is executed outside the transaction.

❓ optimization

expert

How does using MULTI improve Redis command execution?

What is a key benefit of wrapping multiple commands inside MULTI/EXEC in Redis?

A Improves network speed by compressing commands.

B Automatically retries commands on failure.

C Ensures all commands execute atomically without interference from other clients.

D Allows commands to execute in parallel on multiple threads.

💡 Hint

Think about what atomicity means in transactions.

MULTI/EXEC ensures all commands run as a single atomic operation, preventing partial execution.

Practice

1.

What does the MULTI command do in Redis?

easy

A. Immediately executes all commands

B. Starts a transaction block to queue commands

C. Deletes all keys in the database

D. Shows the current database size

Solution

1. Step 1: Understand the purpose of MULTI

   The MULTI command begins a transaction block where commands are queued instead of executed immediately.

2. Step 2: Compare with other options

   The other options describe different Redis commands or actions unrelated to MULTI.

3. Final Answer:

   Starts a transaction block to queue commands -> Option B

4. Quick Check:

   MULTI = start transaction block [OK]

Hint: MULTI queues commands for atomic execution [OK]

Common Mistakes:

• Thinking MULTI executes commands immediately
• Confusing MULTI with FLUSHDB or DBSIZE
• Assuming MULTI deletes keys

2.

Which of the following is the correct syntax to start a transaction block in Redis?

?

easy

A. START TRANSACTION

B. EXEC

C. MULTI

D. BEGIN

Solution

1. Step 1: Identify Redis transaction start command

   In Redis, MULTI is used to start a transaction block.

2. Step 2: Check other options

   EXEC runs queued commands, BEGIN and START TRANSACTION are SQL commands, not Redis.

3. Final Answer:

   MULTI -> Option C

4. Quick Check:

   Start transaction = MULTI [OK]

Hint: MULTI starts, EXEC runs queued commands [OK]

Common Mistakes:

• Using SQL syntax like BEGIN or START TRANSACTION
• Confusing EXEC as start command
• Typing lowercase commands (Redis commands are case-insensitive but usually uppercase)

3.

Consider the following Redis commands executed in order:

MULTI
SET key1 value1
SET key2 value2
EXEC
GET key1
GET key2

What will be the output of the two GET commands?

medium

A. ["value1", "value2"]

B. [null, null]

C. ["value1", null]

D. [null, "value2"]

Solution

1. Step 1: Understand MULTI and EXEC behavior

   The commands between MULTI and EXEC are queued and executed atomically when EXEC runs. So both SET commands run together.

2. Step 2: Check GET commands after EXEC

   After EXEC, both keys are set, so GET key1 returns "value1" and GET key2 returns "value2".

3. Final Answer:

   ["value1", "value2"] -> Option A

4. Quick Check:

   Queued SETs run on EXEC, GET returns set values [OK]

Hint: EXEC runs queued commands, so GET sees updated keys [OK]

Common Mistakes:

• Assuming SET commands run immediately before EXEC
• Expecting null because commands are queued
• Confusing output format of GET commands

4.

What is wrong with this Redis transaction block?

MULTI
SET key1 value1
GET key1
EXEC

medium

A. MULTI must be followed by WATCH

B. EXEC must come before GET

C. SET cannot be used inside MULTI

D. GET inside MULTI queues the command, does not return value immediately

Solution

1. Step 1: Analyze GET inside MULTI block

   Inside MULTI, commands are queued and do not return results immediately, so GET queues but does not return the value now.

2. Step 2: Understand EXEC behavior

   EXEC runs all queued commands and returns their results together, so GET's result is only available after EXEC.

3. Final Answer:

   GET inside MULTI queues the command, does not return value immediately -> Option D

4. Quick Check:

   Commands queue inside MULTI, results after EXEC [OK]

Hint: GET inside MULTI queues, no immediate output [OK]

Common Mistakes:

• Expecting GET to return value immediately inside MULTI
• Thinking EXEC must come before GET
• Believing SET is disallowed inside MULTI

5.

You want to update two keys user:1 and user:2 atomically in Redis. Which sequence correctly uses MULTI and EXEC to ensure both updates happen together?

?

hard

A. MULTI
SET user:1 "Alice"
SET user:2 "Bob"
EXEC

B. SET user:1 "Alice"
MULTI
SET user:2 "Bob"
EXEC

C. MULTI
SET user:1 "Alice"
EXEC
SET user:2 "Bob"

D. EXEC
MULTI
SET user:1 "Alice"
SET user:2 "Bob"

Solution

1. Step 1: Identify correct transaction block

   MULTI SET user:1 "Alice" SET user:2 "Bob" EXEC starts with MULTI, queues both SET commands, then runs them together with EXEC.

2. Step 2: Check other options for errors

   SET user:1 "Alice" MULTI SET user:2 "Bob" EXEC queues only one SET inside MULTI; MULTI SET user:1 "Alice" EXEC SET user:2 "Bob" runs EXEC too early; EXEC MULTI SET user:1 "Alice" SET user:2 "Bob" starts with EXEC which is invalid.

3. Final Answer:

   MULTI SET user:1 "Alice" SET user:2 "Bob" EXEC -> Option A

4. Quick Check:

   Queue all commands between MULTI and EXEC [OK]

Hint: Queue all commands between MULTI and EXEC for atomic update [OK]

Common Mistakes:

• Calling EXEC before queuing all commands
• Starting EXEC before MULTI
• Mixing commands outside transaction block