PERSIST to remove expiry in Redis - Step-by-Step Execution

Concept Flow - PERSIST to remove expiry

Start with a key

↓

Check if key has expiry?

No→Nothing changes

Yes↓

Run PERSIST command

↓

Expiry removed

↓

Key becomes persistent

↓

End

This flow shows how the PERSIST command removes the expiry time from a Redis key, making it permanent.

Execution Sample

Redis

SET session123 user_data
EXPIRE session123 300
TTL session123
PERSIST session123
TTL session123

This code sets a key with expiry, checks its TTL, removes expiry with PERSIST, then checks TTL again.

Execution Table

Step	Command	Key TTL Before	Action	Key TTL After	Result
1	SET session123 user_data	N/A	Create key without expiry	-1	Key created
2	EXPIRE session123 300	-1	Set expiry 300 seconds	300	Expiry set
3	TTL session123	300	Check TTL	300	TTL is 300 seconds
4	PERSIST session123	300	Remove expiry	-1	Expiry removed, key persistent
5	TTL session123	-1	Check TTL	-1	TTL is -1 (no expiry)

💡 After PERSIST, TTL is -1 meaning no expiry remains on the key.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5
TTL(session123)	N/A	-1	300	300	-1	-1

Key Moments - 3 Insights

Why does TTL show -1 after SET but before EXPIRE?

Because the key was created without expiry, TTL returns -1 indicating no expiration (see execution_table step 1).

What does PERSIST do to the key's TTL?

PERSIST removes the expiry, changing TTL from a positive number to -1, meaning the key will not expire (see execution_table step 4).

Why check TTL after PERSIST?

To confirm the expiry was removed and the key is now persistent (see execution_table step 5).

Visual Quiz - 3 Questions

Look at the execution_table, what is the TTL of 'session123' right after the EXPIRE command?

A -1

B 0

C 300

D N/A

💡 Hint

Check the 'Key TTL After' column at step 2 in the execution_table.

At which step does the key become persistent with no expiry?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look for when TTL changes to -1 after being positive in the execution_table.

If we skip the PERSIST command, what would TTL show at step 5?

A 300

B -1

C 0

D N/A

💡 Hint

Without PERSIST, expiry remains so TTL stays positive (see step 3 and 5 comparison).

Concept Snapshot

PERSIST key
- Removes expiry from a Redis key
- Makes key persistent (TTL = -1)
- Use after EXPIRE to keep key forever
- TTL command shows -1 if no expiry
- Useful to cancel automatic deletion

Full Transcript

This visual execution shows how the Redis PERSIST command removes the expiry time from a key. First, a key 'session123' is created without expiry (TTL is -1). Then expiry is set to 300 seconds. Checking TTL confirms 300 seconds remain. Running PERSIST removes the expiry, changing TTL back to -1, meaning the key will not expire. Checking TTL again confirms no expiry remains. This helps understand how PERSIST cancels expiry on keys.

Practice

1. What does the Redis command PERSIST key do?

easy

A. Renames the key to 'persisted_key'

B. Sets a new expiration time on the key

C. Deletes the key immediately

D. Removes the expiration time from the key, making it permanent

Solution

1. Step 1: Understand the purpose of PERSIST

   The PERSIST command removes any expiration time set on a Redis key, so the key no longer expires.

2. Step 2: Compare with other commands

   Unlike EXPIRE which sets a timeout, PERSIST cancels it. It does not delete or rename the key.

3. Final Answer:

   Removes the expiration time from the key, making it permanent -> Option D

4. Quick Check:

   PERSIST removes expiry = Removes the expiration time from the key, making it permanent [OK]

Hint: PERSIST cancels expiry, keeps key forever [OK]

Common Mistakes:

• Confusing PERSIST with EXPIRE
• Thinking PERSIST deletes the key
• Assuming PERSIST renames the key

2. Which of the following is the correct syntax to remove expiry from a Redis key named session123?

easy

A. PERSIST session123

B. REMOVEEXPIRY session123

C. EXPIRE session123 0

D. TTL session123

Solution

1. Step 1: Recall the correct command for removing expiry

   The Redis command to remove expiry is PERSIST key. So for key 'session123', it is PERSIST session123.

2. Step 2: Check other options

   REMOVEEXPIRY is not a Redis command. EXPIRE with 0 does not remove expiry but sets it to expire immediately. TTL only checks expiry time.

3. Final Answer:

   PERSIST session123 -> Option A

4. Quick Check:

   Correct syntax for removing expiry = PERSIST session123 [OK]

Hint: Use PERSIST key to remove expiry [OK]

Common Mistakes:

• Using EXPIRE with 0 to remove expiry
• Trying non-existent commands like REMOVEEXPIRY
• Confusing TTL with expiry removal

3. Given the following Redis commands executed in order:

SET mykey "hello"
EXPIRE mykey 10
TTL mykey
PERSIST mykey
TTL mykey

What will be the output of the two TTL commands?

medium

A. 10 and -1

B. -1 and 10

C. 10 and 10

D. -1 and -1

Solution

1. Step 1: Analyze the first TTL after EXPIRE

   After setting key 'mykey' and applying EXPIRE 10, TTL returns the remaining seconds, which is 10.

2. Step 2: Analyze the second TTL after PERSIST

   PERSIST removes expiry, so TTL returns -1 indicating no expiration.

3. Final Answer:

   10 and -1 -> Option A

4. Quick Check:

   TTL before persist = 10, after persist = -1 [OK]

Hint: TTL shows seconds left; PERSIST makes TTL -1 [OK]

Common Mistakes:

• Expecting TTL to stay 10 after PERSIST
• Confusing TTL -1 meaning
• Thinking PERSIST sets TTL to 0

4. You run the command PERSIST mykey but it returns 0. What is the most likely reason?

medium

A. The key does not exist

B. The key has no expiry set

C. The key is already persistent

D. The command syntax is incorrect

Solution

1. Step 1: Understand PERSIST return values

   PERSIST returns 1 if expiry was removed, 0 if key had no expiry or key does not exist.

2. Step 2: Differentiate between no expiry and missing key

   If key does not exist, PERSIST returns 0, but usually you check key existence first. If key exists but no expiry, PERSIST returns 0 because nothing to remove.

3. Final Answer:

   The key has no expiry set -> Option B

4. Quick Check:

   PERSIST returns 0 if no expiry to remove [OK]

Hint: PERSIST returns 0 if no expiry on key [OK]

Common Mistakes:

• Assuming 0 means syntax error
• Confusing no expiry with key missing
• Thinking 0 means key deleted

5. You have a Redis key cache:item with an expiry of 30 seconds. You want to keep it permanently only if its current TTL is more than 10 seconds. Which sequence of commands achieves this safely?

hard

A. Run EXPIRE cache:item 0 to remove expiry

B. Run PERSIST cache:item directly without checking TTL

C. Use TTL cache:item, then if result > 10, run PERSIST cache:item

D. Rename the key to a new key without expiry

Solution

1. Step 1: Check current TTL of the key

   Use TTL cache:item to get remaining expiry time in seconds.

2. Step 2: Conditionally remove expiry

   If TTL is more than 10, run PERSIST cache:item to remove expiry and keep key permanently.

3. Step 3: Avoid wrong commands

   Running PERSIST without checking TTL removes expiry regardless. EXPIRE with 0 does not remove expiry but sets immediate expiry. Renaming does not affect expiry.

4. Final Answer:

   Use TTL, then if > 10, run PERSIST -> Option C

5. Quick Check:

   Check TTL before PERSIST to keep key only if TTL > 10 [OK]

Hint: Check TTL first, then PERSIST if TTL > 10 [OK]

Common Mistakes:

• Running PERSIST blindly without TTL check
• Using EXPIRE 0 to remove expiry
• Thinking renaming removes expiry