Keyset pagination for performance in Rest API - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of keyset pagination query

Consider a REST API that uses keyset pagination on a table sorted by created_at and id. What is the output of the following SQL snippet when last_seen_created_at = '2024-01-01 10:00:00' and last_seen_id = 100?

SELECT * FROM posts WHERE (created_at, id) < (:last_seen_created_at, :last_seen_id) ORDER BY created_at DESC, id DESC LIMIT 3;

Rest API

last_seen_created_at = '2024-01-01 10:00:00'
last_seen_id = 100

-- Assume posts table has these rows sorted by created_at DESC, id DESC:
-- (2024-01-01 10:00:00, 100), (2024-01-01 09:59:59, 105), (2024-01-01 09:59:59, 102), (2024-01-01 09:59:58, 110), (2024-01-01 09:59:57, 101)

A Rows with (2024-01-01 10:00:00, 101), (2024-01-01 09:59:59, 105), (2024-01-01 09:59:58, 110)

B Rows with (2024-01-01 10:00:00, 100), (2024-01-01 09:59:59, 105), (2024-01-01 09:59:59, 102)

C Rows with (2024-01-01 09:59:59, 105), (2024-01-01 09:59:59, 102), (2024-01-01 09:59:58, 110)

D Rows with (2024-01-01 09:59:58, 110), (2024-01-01 09:59:57, 101), (2024-01-01 09:59:59, 102)

💡 Hint

Remember that keyset pagination uses the tuple comparison to get rows strictly less than the last seen key.

The query fetches rows where the tuple (created_at, id) is less than (2024-01-01 10:00:00, 100) in descending order. So it excludes the last seen row and gets the next 3 rows with smaller tuples.

🧠 Conceptual

intermediate

Why use keyset pagination over offset pagination?

Which of the following is the main reason to prefer keyset pagination over offset pagination in REST APIs?

A Keyset pagination avoids skipping rows and is faster on large datasets.

B Keyset pagination allows jumping to any page number instantly.

C Keyset pagination requires less client-side state management.

D Keyset pagination always returns results in random order.

💡 Hint

Think about how offset pagination slows down as the offset grows.

Offset pagination becomes slower with large offsets because the database must scan and skip many rows. Keyset pagination uses the last seen key to efficiently fetch the next set without scanning skipped rows.

🔧 Debug

advanced

Identify the bug in keyset pagination query

Find the bug in this keyset pagination SQL query snippet:

SELECT * FROM messages WHERE created_at < :last_seen_created_at ORDER BY created_at DESC LIMIT 5;

Assume last_seen_created_at is the timestamp of the last message from the previous page.

A It can skip messages with the same created_at timestamp as last_seen_created_at.

B It will return duplicate messages from the previous page.

C It uses ascending order instead of descending order.

D It does not limit the number of rows returned.

💡 Hint

Think about what happens if multiple messages share the same timestamp.

The query only filters by created_at < last_seen_created_at, so messages with the same timestamp as the last seen message are skipped entirely, causing missing data. Keyset pagination should include a tie-breaker column like id to avoid this.

📝 Syntax

advanced

Correct keyset pagination WHERE clause syntax

Which option correctly implements a keyset pagination WHERE clause for sorting by created_at DESC and id DESC with last seen values :last_created_at and :last_id?

A WHERE created_at > :last_created_at AND id > :last_id

B WHERE (created_at, id) < (:last_created_at, :last_id)

C WHERE created_at > :last_created_at OR (created_at = :last_created_at AND id > :last_id)

D WHERE created_at < :last_created_at OR (created_at = :last_created_at AND id < :last_id)

💡 Hint

Remember that for descending order, smaller tuples come after larger ones.

Option D correctly expresses the tuple comparison for descending order by checking if created_at is less than last_created_at or equal but id is less. Option D is invalid syntax in many SQL dialects. Options C and D use the wrong comparison direction.

🚀 Application

expert

Implement keyset pagination in REST API response

You have a REST API endpoint that returns a list of products sorted by updated_at DESC and product_id DESC. You want to implement keyset pagination. Which approach correctly returns the next page token and the next page of results?

A Return the current page number and use <code>OFFSET page_number * page_size</code> in the next request to fetch the next page.

B Return the last product's <code>updated_at</code> and <code>product_id</code> as a cursor token. Use them in the next request to filter with <code>WHERE (updated_at, product_id) &lt; (:last_updated_at, :last_product_id)</code> and order by <code>updated_at DESC, product_id DESC</code>.

C Return the total count of products and calculate the next page by dividing count by page size.

D Return the first product's <code>updated_at</code> and <code>product_id</code> as a cursor token and filter with <code>WHERE (updated_at, product_id) &gt; (:first_updated_at, :first_product_id)</code>.

💡 Hint

Keyset pagination uses the last seen key to fetch the next page efficiently.

Option B correctly uses the last product's keys as a cursor token and filters the next page with a tuple comparison in descending order. Option B uses offset pagination, which is less efficient. Option B is unrelated to keyset pagination. Option B uses the first product's keys and the wrong comparison direction.

Practice

1. What is the main advantage of using keyset pagination over traditional offset-based pagination in REST APIs?

easy

A. It requires less server memory by caching all pages in advance.

B. It allows jumping to any page number directly without sequential access.

C. It improves performance by avoiding slow offset queries on large datasets.

D. It automatically sorts data in descending order without extra code.

Solution

1. Step 1: Understand offset-based pagination issues

   Offset pagination uses a page number and offset, which becomes slow on large datasets because the database must skip many rows.

2. Step 2: Recognize keyset pagination benefits

   Keyset pagination uses a fixed key (like an ID) to fetch the next set of rows, avoiding the costly skip operation and improving performance.

3. Final Answer:

   It improves performance by avoiding slow offset queries on large datasets. -> Option C

4. Quick Check:

   Keyset pagination = better performance [OK]

Hint: Keyset uses keys, not offsets, for faster queries [OK]

Common Mistakes:

• Thinking keyset allows random page jumps
• Assuming keyset caches all data
• Believing keyset changes sort order automatically

2. Which of the following is the correct SQL snippet to implement keyset pagination for a table users ordered by id?

easy

A. SELECT * FROM users ORDER BY id LIMIT 10 OFFSET 20;

B. SELECT * FROM users WHERE id > 20 ORDER BY id LIMIT 10;

C. SELECT * FROM users WHERE id = 20 ORDER BY id LIMIT 10;

D. SELECT * FROM users ORDER BY id DESC LIMIT 10 OFFSET 20;

Solution

1. Step 1: Identify keyset pagination syntax

   Keyset pagination uses a WHERE clause with a key (like id > last_seen_id) and a LIMIT to fetch the next page.

2. Step 2: Analyze each option

   SELECT * FROM users WHERE id > 20 ORDER BY id LIMIT 10; uses WHERE id > 20 with ORDER BY id LIMIT 10, which matches keyset pagination logic.

3. Final Answer:

   SELECT * FROM users WHERE id > 20 ORDER BY id LIMIT 10; -> Option B

4. Quick Check:

   Keyset uses WHERE key > last_key [OK]

Hint: Keyset uses WHERE with key comparison, not OFFSET [OK]

Common Mistakes:

• Using OFFSET instead of WHERE for pagination
• Using equality (=) instead of greater than (>)
• Not ordering results by the key column

3. Given this REST API endpoint using keyset pagination:

GET /items?last_id=50&limit=5

And the database table items with IDs: [45, 47, 50, 52, 55, 60, 65], what will be the IDs returned by this request?

medium

A. [52, 55, 60, 65]

B. [45, 47, 50, 52, 55]

C. [52, 55, 60, 65, 70]

D. [51, 52, 53, 54, 55]

Solution

1. Step 1: Understand keyset pagination with last_id=50

   The API returns items with IDs greater than 50, limited to 5 results.

2. Step 2: Select IDs greater than 50 from the list

   IDs greater than 50 are [52, 55, 60, 65]. There are only 4 such items, so all are returned.

3. Final Answer:

   [52, 55, 60, 65] -> Option A

4. Quick Check:

   IDs > 50 limited to 5 = [52, 55, 60, 65] [OK]

Hint: Return items with ID > last_id, up to limit [OK]

Common Mistakes:

• Including items with ID equal to last_id
• Using offset instead of key comparison
• Assuming IDs are continuous numbers

4. You have this SQL query for keyset pagination:

SELECT * FROM orders WHERE order_date > '2024-01-01' ORDER BY order_date LIMIT 10;

But it returns duplicate rows when new orders are added. What is the likely cause?

medium

A. Ordering by a non-unique column causing duplicates

B. LIMIT value is too high causing repeats

C. Missing OFFSET clause to skip duplicates

D. Using > instead of >= in WHERE clause

Solution

1. Step 1: Identify ordering column uniqueness

   Ordering by order_date alone can cause duplicates if multiple rows share the same date.

2. Step 2: Understand keyset pagination requirements

   Keyset pagination requires ordering by a unique column or combination to avoid duplicates and missing rows.

3. Final Answer:

   Ordering by a non-unique column causing duplicates -> Option A

4. Quick Check:

   Order by unique key to avoid duplicates [OK]

Hint: Order by unique keys to prevent duplicates [OK]

Common Mistakes:

• Thinking OFFSET fixes duplicates
• Using >= instead of > causes duplicates
• Assuming LIMIT controls duplicates

5. You want to implement keyset pagination on a REST API that returns products sorted by price ascending, then by id ascending to break ties.
Which SQL WHERE clause correctly fetches the next page after last product with price=100 and id=50?

hard

A. WHERE price > 100 OR id > 50

B. WHERE price >= 100 AND id > 50

C. WHERE price > 100 AND id > 50

D. WHERE price > 100 OR (price = 100 AND id > 50)

Solution

1. Step 1: Understand multi-column keyset pagination

   When ordering by multiple columns, the WHERE clause must handle the first column and then the second to break ties.

2. Step 2: Analyze the correct condition

   The correct condition is price > 100 OR (price = 100 AND id > 50) to get all rows with higher price or same price but higher id.

3. Final Answer:

   WHERE price > 100 OR (price = 100 AND id > 50) -> Option D

4. Quick Check:

   Multi-column keyset uses OR + AND for tie-break [OK]

Hint: Use OR with AND to handle multi-column keys [OK]

Common Mistakes:

• Using AND instead of OR for first column
• Ignoring tie-break column in WHERE clause
• Using >= instead of > causing duplicates