Lua vs transactions comparison in Redis - Hands-On Comparison

Using Lua Scripts and Transactions in Redis

📖 Scenario: You are managing a Redis database for a small online store. You want to update the stock quantity of a product safely when a purchase happens. You will learn two ways to do this: using Lua scripts and using Redis transactions.

🎯 Goal: Build two Redis commands: one using a Lua script to safely decrease stock if enough quantity exists, and another using Redis transactions to do the same. This will help you understand the difference between Lua scripting and transactions in Redis.

📋 What You'll Learn

Create a Redis key product_stock with initial value 10

Create a Lua script that decreases product_stock by 3 only if stock is enough

Create a transaction that watches product_stock and decreases it by 3 safely

Compare the Lua script and transaction approach in terms of atomicity and simplicity

💡 Why This Matters

🌍 Real World

Managing stock quantities in an online store requires safe updates to avoid selling more items than available.

💼 Career

Understanding Redis Lua scripts and transactions is important for backend developers working with Redis to ensure data consistency and atomic operations.

1

DATA SETUP: Create the initial stock key

Use the Redis command SET product_stock 10 to create a key called product_stock with the value 10.

Redis

# Your Redis command here

Hint

Use the SET command to create a key with a number value.

2

CONFIGURATION: Write the Lua script to decrease stock

Write a Lua script that gets the current stock from product_stock, checks if it is at least 3, and if yes, decreases it by 3 and returns the new stock. Use redis.call('GET', 'product_stock') and redis.call('SET', 'product_stock', new_stock).

Redis

SET product_stock 10
-- Write Lua script to decrease stock by 3 if enough

Hint

Use redis.call to get and set the key inside the Lua script.

3

CORE LOGIC: Use Redis transactions to decrease stock safely

Use Redis commands to watch product_stock, get its value, check if it is at least 3, then start a transaction with MULTI, decrease the stock by 3 with SET, and execute with EXEC. Use WATCH product_stock before reading the value.

Redis

SET product_stock 10
local stock = tonumber(redis.call('GET', 'product_stock'))
if stock >= 3 then
  local new_stock = stock - 3
  redis.call('SET', 'product_stock', new_stock)
  return new_stock
else
  return -1
end
-- Use WATCH, MULTI, SET, EXEC to decrease stock by 3 safely

Hint

Use WATCH before reading, then MULTI to start transaction, SET to update, and EXEC to commit.

4

COMPLETION: Add a comment comparing Lua scripts and transactions

Add a comment explaining that Lua scripts run atomically and are simpler for this use case, while transactions require watching keys and can fail if keys change.

Redis

SET product_stock 10
local stock = tonumber(redis.call('GET', 'product_stock'))
if stock >= 3 then
  local new_stock = stock - 3
  redis.call('SET', 'product_stock', new_stock)
  return new_stock
else
  return -1
end
WATCH product_stock
local current_stock = tonumber(redis.call('GET', 'product_stock'))
if current_stock >= 3 then
  MULTI
  SET product_stock (current_stock - 3)
  EXEC
else
  UNWATCH
end
-- Add comment comparing Lua scripts and transactions

Hint

Write a clear comment comparing the two methods.

Practice

1. Which statement best describes the difference between Lua scripts and transactions in Redis?

easy

A. Transactions are faster and more flexible than Lua scripts.

B. Transactions can execute complex logic, Lua scripts only group commands.

C. Lua scripts allow complex logic, while transactions group simple commands atomically.

D. Both Lua scripts and transactions cannot guarantee atomic execution.

Solution

1. Step 1: Understand atomic execution in Redis

   Both Lua scripts and transactions ensure commands run atomically, meaning all commands execute as one unit without interruption.

2. Step 2: Compare complexity and usage

   Lua scripts allow embedding complex logic and multiple commands in one script, while transactions simply group commands without logic.

3. Final Answer:

   Lua scripts allow complex logic, while transactions group simple commands atomically. -> Option C

4. Quick Check:

   Lua = complex logic, transactions = simple groups [OK]

Hint: Lua = complex logic, transactions = simple command groups [OK]

Common Mistakes:

• Thinking transactions can run complex logic
• Believing Lua scripts do not guarantee atomicity
• Confusing speed differences between Lua and transactions

2. Which of the following is the correct way to start a transaction in Redis?

easy

A. MULTI

B. EVAL

C. EXEC

D. SCRIPT

Solution

1. Step 1: Recall Redis transaction commands

   Redis transactions start with the MULTI command to begin queuing commands.

2. Step 2: Identify correct command usage

   EXEC is used to execute queued commands, EVAL runs Lua scripts, SCRIPT manages scripts, so MULTI is the correct start.

3. Final Answer:

   MULTI -> Option A

4. Quick Check:

   Start transaction with MULTI [OK]

Hint: Start transactions with MULTI, execute with EXEC [OK]

Common Mistakes:

• Using EXEC to start a transaction
• Confusing EVAL with transaction commands
• Using SCRIPT to start transactions

3. Given the following Lua script executed in Redis:

local val = redis.call('GET', KEYS[1])
if val == nil then
  redis.call('SET', KEYS[1], ARGV[1])
  return ARGV[1]
else
  return val
end

What will be the output if the key does not exist and ARGV[1] is "hello"?

medium

A. Error

B. nil

C. false

D. "hello"

Solution

1. Step 1: Check key existence with redis.call('GET')

   If the key does not exist, redis.call('GET') returns nil in Lua script context.

2. Step 2: Set key and return ARGV[1]

   Since val == nil, the script sets the key to ARGV[1] which is "hello" and returns "hello".

3. Final Answer:

   "hello" -> Option D

4. Quick Check:

   Key missing sets and returns ARGV[1] = "hello" [OK]

Hint: If key missing, Lua script sets and returns ARGV[1] [OK]

Common Mistakes:

• Thinking GET returns false instead of nil
• Expecting nil or error instead of returned value
• Confusing Lua false with Redis nil

4. You wrote this Redis transaction:

MULTI
GET key1
SET key1 value1
EXEC

But the GET command returns nil instead of "value1". What is the likely cause?

medium

A. GET command syntax is incorrect

B. GET runs before SET executes in transaction

C. EXEC was not called to execute commands

D. Redis transactions do not guarantee atomicity

Solution

1. Step 1: Understand Redis transaction command queuing

   Commands inside MULTI are queued and executed only after EXEC; GET does not see SET effect during queuing.

2. Step 2: Explain why GET returns nil

   GET is queued before SET, so during EXEC it executes first and returns nil because SET has not been applied yet.

3. Final Answer:

   GET runs before SET executes in transaction -> Option B

4. Quick Check:

   Queued commands run after EXEC, GET sees old value [OK]

Hint: Queued commands run after EXEC; GET sees old value during queue [OK]

Common Mistakes:

• Thinking commands run immediately inside MULTI
• Assuming GET syntax error causes nil
• Believing EXEC was not called

5. You want to atomically increment a counter only if its current value is less than 10. Which approach is best in Redis?

hard

A. Use a Lua script to check and increment atomically

B. Use MULTI/EXEC transaction with GET and INCR commands

C. Run GET and INCR commands separately in client code

D. Use WATCH on the key and then INCR without Lua

Solution

1. Step 1: Understand atomic conditional increment need

   Increment only if value < 10 requires checking and updating atomically to avoid race conditions.

2. Step 2: Compare Lua script vs transactions

   Lua scripts run all logic atomically in Redis, while transactions cannot conditionally check and increment atomically without race.

3. Step 3: Evaluate WATCH option

   WATCH can detect changes but requires retry logic and is less clean than Lua script for this logic.

4. Final Answer:

   Use a Lua script to check and increment atomically -> Option A

5. Quick Check:

   Lua scripts handle complex atomic logic best [OK]

Hint: Use Lua for atomic conditional logic, transactions can't do it alone [OK]

Common Mistakes:

• Assuming transactions can do conditional increments atomically
• Ignoring race conditions with separate GET and INCR
• Overestimating WATCH simplicity without retries