EXEC to execute in Redis - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the Redis command EXEC do?

The EXEC command runs all the commands queued in a transaction started by MULTI. It executes them atomically (sequentially without interleaving from other clients).

beginner

Which Redis command must be called before EXEC to start queuing commands?

The MULTI command starts a transaction and queues commands until EXEC is called to execute them.

intermediate

What happens if a command inside a Redis transaction fails before EXEC is called?

Redis returns an error immediately for the invalid command (e.g., syntax error), does not queue it, but continues the transaction. EXEC executes all successfully queued commands.

beginner

Can Redis commands queued in a transaction be executed partially with EXEC?

No. EXEC executes all queued commands atomically.

beginner

How do you cancel a Redis transaction before calling EXEC?

Use the DISCARD command to cancel all queued commands and exit the transaction without executing them.

What is the purpose of the Redis EXEC command?

A Check the status of a transaction

B Start a new transaction

C Cancel the current transaction

D Execute all commands queued in a transaction

EXEC runs all commands queued after MULTI atomically.

Which command must be used before EXEC to queue commands in Redis?

A DISCARD

B EXEC

C MULTI

D WATCH

MULTI starts the transaction and queues commands until EXEC is called.

What happens if an invalid command is issued during a Redis transaction before EXEC runs?

A Only valid commands execute

B Transaction is aborted and no commands run

C Invalid commands are skipped

D Redis fixes the invalid command automatically

Invalid commands cause an error and are not queued; only valid commands execute on EXEC.

How can you cancel a Redis transaction before executing it?

A Use <code>EXEC</code>

B Use <code>DISCARD</code>

C Use <code>WATCH</code>

D Use <code>FLUSHDB</code>

DISCARD cancels all queued commands and exits the transaction.

Is it possible to execute only some commands from a Redis transaction with EXEC?

A No, all commands execute atomically

B Yes, you can choose commands to execute

C Yes, but only if commands are independent

D Only if you use <code>WATCH</code>

EXEC executes all queued commands atomically.

Explain how the Redis EXEC command works in a transaction.

Think about how transactions ensure all commands run together.

Describe the difference between EXEC and DISCARD in Redis transactions.

One commits the transaction, the other cancels it.

Practice

1. What does the EXEC command do in Redis transactions?

easy

A. It runs all queued commands in a transaction at once.

B. It starts queuing commands for a transaction.

C. It cancels all queued commands in a transaction.

D. It checks the status of the Redis server.

Solution

1. Step 1: Understand Redis transaction commands

   The MULTI command starts queuing commands, and EXEC runs them all together.

2. Step 2: Identify the role of EXEC

   EXEC executes all commands queued after MULTI in one atomic operation.

3. Final Answer:

   It runs all queued commands in a transaction at once. -> Option A

4. Quick Check:

   EXEC runs queued commands = B [OK]

Hint: Remember: MULTI queues, EXEC runs all queued commands [OK]

Common Mistakes:

• Confusing EXEC with MULTI
• Thinking EXEC cancels commands
• Assuming EXEC checks server status

2. Which of the following is the correct sequence to run multiple commands atomically in Redis?

easy

A. SET key value, EXEC, MULTI

B. EXEC, MULTI, SET key value

C. MULTI, SET key value, EXEC

D. SET key value, MULTI, EXEC

Solution

1. Step 1: Recall the transaction command order

   First, MULTI starts the transaction, then commands like SET queue, and finally EXEC runs them.

2. Step 2: Match the correct order

   MULTI, SET key value, EXEC follows this order: MULTI, then SET, then EXEC.

3. Final Answer:

   MULTI, SET key value, EXEC -> Option C

4. Quick Check:

   Start with MULTI, end with EXEC = A [OK]

Hint: MULTI starts, EXEC ends the transaction [OK]

Common Mistakes:

• Putting EXEC before MULTI
• Running SET before MULTI
• Mixing command order

3. Given the following Redis commands executed in order:

MULTI
SET user:1:name "Alice"
INCR user:1:visits
EXEC

What will be the result of the EXEC command?

medium

A. An error because INCR on a string key

B. ["OK", 1]

C. ["QUEUED", "QUEUED"]

D. Empty array []

Solution

1. Step 1: Analyze queued commands

   SET user:1:name "Alice" sets a string key, returns "OK"; INCR user:1:visits increments a numeric key, returns the new value.

2. Step 2: Understand EXEC output

   EXEC returns an array with results of each command: ["OK", 1].

3. Final Answer:

   ["OK", 1] -> Option B

4. Quick Check:

   EXEC returns results array = C [OK]

Hint: EXEC returns results of all queued commands in order [OK]

Common Mistakes:

• Expecting QUEUED responses from EXEC
• Thinking INCR causes error on string key
• Assuming EXEC returns empty array

4. You run the following Redis commands:

MULTI
SET key1 "value1"
GET key1
EXEC

What will be the result of the EXEC command?

medium

A. An error because GET command is not allowed inside MULTI block

B. You forgot to call MULTI before queuing commands

C. The GET command returns QUEUED, causing EXEC to fail

D. No error; EXEC always succeeds if MULTI was called

Solution

1. Step 1: Understand command behavior in transactions

   Some commands like GET are allowed but return QUEUED during MULTI, and EXEC returns their results after execution.

2. Step 2: Identify that no error occurs

   GET is fully supported inside MULTI/EXEC blocks, so EXEC succeeds and returns ["OK", "value1"].

3. Final Answer:

   No error; EXEC always succeeds if MULTI was called -> Option D

4. Quick Check:

   GET inside MULTI causes no error = D [OK]

Hint: Check if commands are allowed inside MULTI before EXEC [OK]

Common Mistakes:

• Assuming all commands work inside MULTI
• Forgetting to call MULTI before EXEC
• Expecting EXEC to never fail

5. You want to increment a counter atomically with optimistic locking (aborting if the key was modified meanwhile), using Redis transactions. Which sequence correctly uses WATCH, MULTI, and EXEC to do this safely?

hard

A. WATCH counter
MULTI
INCR counter
EXEC

B. MULTI
WATCH counter
INCR counter
EXEC

C. MULTI
INCR counter
EXEC
WATCH counter

D. INCR counter
WATCH counter
MULTI
EXEC

Solution

1. Step 1: Understand WATCH usage

   WATCH monitors keys for changes before starting a transaction with MULTI.

2. Step 2: Correct command order for safe increment

   First WATCH counter, then MULTI, queue INCR counter, and finally EXEC to run if no changes occurred.

3. Final Answer:

   WATCH counter MULTI INCR counter EXEC -> Option A

4. Quick Check:

   WATCH before MULTI for safe transactions = D [OK]

Hint: Always WATCH keys before MULTI to ensure safe EXEC [OK]

Common Mistakes:

• Calling WATCH after MULTI
• Running INCR before WATCH
• Not using WATCH for conditional updates