Keyset pagination for performance in Rest API

Introduction

Keyset pagination helps load data faster by using a fixed point to continue fetching results instead of counting all items each time.

When you have a large list of items and want to show them page by page without slowing down.

When users scroll through a feed or timeline and you want to load new items smoothly.

When counting total items is expensive or not needed for the user experience.

When you want to avoid skipping or repeating items when data changes during pagination.

Syntax

Rest API

GET /items?limit=10&after_id=123

limit sets how many items to fetch per page.

after_id tells the server to return items with IDs greater than this value.

Examples

Fetch 20 products with IDs greater than 50.

Rest API

GET /products?limit=20&after_id=50

Get 15 messages after message ID 200.

Rest API

GET /messages?limit=15&after_id=200

Get the first 10 posts (no cursor yet).

Rest API

GET /posts?limit=10

Sample Program

This simple REST API returns items in pages using keyset pagination. It uses the 'after_id' query to fetch items with IDs greater than the given value. If no 'after_id' is given, it returns the first page.

Rest API

from flask import Flask, request, jsonify

app = Flask(__name__)

# Sample data: list of items with id and name
items = [{'id': i, 'name': f'Item {i}'} for i in range(1, 101)]

@app.route('/items')
def get_items():
    limit = int(request.args.get('limit', 10))
    after_id = request.args.get('after_id')

    if after_id is not None:
        after_id = int(after_id)
        filtered = [item for item in items if item['id'] > after_id]
    else:
        filtered = items

    result = filtered[:limit]
    return jsonify(result)

if __name__ == '__main__':
    app.run(debug=True)

Important Notes

Keyset pagination is faster than offset pagination because it avoids counting or skipping rows.

Use a unique and indexed column (like an ID) for the cursor to keep results consistent.

Remember to handle the case when there are no more items to fetch.

Summary

Keyset pagination uses a fixed point (cursor) to fetch the next page of results efficiently.

It is great for large datasets and real-time feeds where counting all items is slow.

Use query parameters like limit and after_id to control pagination.

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