Pagination patterns in FastAPI - Step-by-Step Execution

Concept Flow - Pagination patterns

Client sends request with page info

↓

Server receives request

↓

Calculate offset and limit

↓

Query database with offset and limit

↓

Return subset of data + metadata

↓

Client displays current page data

↓

User navigates to next/prev page

↩Back to Client sends request

The client requests a specific page; the server calculates which items to fetch, queries the database, and returns only that page's data with info for navigation.

Execution Sample

FastAPI

from fastapi import FastAPI, Query
app = FastAPI()

@app.get('/items/')
async def read_items(page: int = 1, size: int = 10):
    offset = (page - 1) * size
    return {'offset': offset, 'limit': size}

This FastAPI endpoint calculates offset and limit for pagination based on page and size query parameters.

Execution Table

Step	Input (page, size)	Calculate offset	Calculate limit	Return value
1	page=1, size=10	(1-1)*10 = 0	10	{'offset': 0, 'limit': 10}
2	page=2, size=10	(2-1)*10 = 10	10	{'offset': 10, 'limit': 10}
3	page=3, size=5	(3-1)*5 = 10	5	{'offset': 10, 'limit': 5}
4	page=0, size=10	(0-1)*10 = -10	10	{'offset': -10, 'limit': 10}
5	page=1, size=0	(1-1)*0 = 0	0	{'offset': 0, 'limit': 0}
6	page=1, size=10	(1-1)*10 = 0	10	{'offset': 0, 'limit': 10}

💡 Execution ends after returning offset and limit for given page and size parameters.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	Final
page	1	1	2	3	0	1	1
size	10	10	10	5	10	0	10
offset	0	0	10	10	-10	0	0
limit	10	10	10	5	10	0	10

Key Moments - 3 Insights

Why does offset become negative when page is 0?

Because offset is calculated as (page - 1) * size, if page is 0, offset is (0-1)*size = -size, which is negative and usually invalid for database queries. See execution_table row 4.

What happens if size is 0?

Limit becomes 0, meaning no items will be fetched. This might cause empty results. See execution_table row 5.

Why do we calculate offset as (page - 1) * size?

Because page 1 should start at item 0, so offset 0 means start from first item. Page 2 starts after first page items, so offset is size, etc. See execution_table rows 1-3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the offset when page=3 and size=5?

A 10

B 5

C 15

D 0

💡 Hint

Check execution_table row 3 under 'Calculate offset'

At which step does the offset become negative?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look for negative offset value in execution_table

If size changes to 20 at page 1, what will the offset be?

A 1

B 20

C 0

D 19

💡 Hint

Offset = (page - 1) * size, check variable_tracker for offset calculation

Concept Snapshot

Pagination in FastAPI:
- Use query params: page (default 1), size (default 10)
- Calculate offset = (page - 1) * size
- Use offset and limit in DB query
- Return subset of data
- Handle edge cases: page < 1 or size <= 0
- Provide metadata for client navigation

Full Transcript

This visual execution shows how pagination works in FastAPI. The client sends page and size parameters. The server calculates offset as (page - 1) times size to know where to start fetching items. Limit is the number of items per page. The server returns these values to fetch a subset of data. The execution table traces different inputs and their offset and limit results. Negative offsets happen if page is less than 1, which is usually invalid. Size zero means no items fetched. This pattern helps clients request data page by page efficiently.

Practice

1. What is the main purpose of pagination in a FastAPI application?

easy

A. To split large data sets into smaller, manageable parts

B. To speed up the server hardware

C. To encrypt data before sending it

D. To change the database schema automatically

Solution

1. Step 1: Understand pagination concept

   Pagination divides large data into smaller chunks to avoid overwhelming users or servers.

2. Step 2: Identify the main goal in FastAPI

   FastAPI uses pagination to send only a part of data per request, improving performance and usability.

3. Final Answer:

   To split large data sets into smaller, manageable parts -> Option A

4. Quick Check:

   Pagination = split data [OK]

Hint: Pagination means breaking data into pages [OK]

Common Mistakes:

• Thinking pagination speeds up hardware
• Confusing pagination with encryption
• Assuming pagination changes database structure

2. Which of the following is the correct way to declare pagination parameters in a FastAPI endpoint using query parameters?

easy

A. def get_items(offset: str = '0', count: str = '10'):

B. def get_items(page: str = '1', size: str = '10'):

C. def get_items(skip: int = 0, limit: int = 10):

D. def get_items(start: int, end: int):

Solution

1. Step 1: Check parameter types for pagination

   Pagination parameters should be integers with default values for skip and limit.

2. Step 2: Validate correct syntax in FastAPI

   Using skip and limit as integers with defaults is standard and valid for query parameters.

3. Final Answer:

   def get_items(skip: int = 0, limit: int = 10): -> Option C

4. Quick Check:

   skip and limit as int with defaults [OK]

Hint: Use int with defaults for skip and limit [OK]

Common Mistakes:

• Using strings instead of integers for pagination
• Missing default values for query parameters
• Using unclear parameter names like start/end

3. Given this FastAPI endpoint snippet, what will be the output if called with ?skip=2&limit=3 on a list [10, 20, 30, 40, 50, 60]?

items = [10, 20, 30, 40, 50, 60]

@app.get('/items')
def read_items(skip: int = 0, limit: int = 5):
    return items[skip : skip + limit]

medium

A. [40, 50, 60]

B. [20, 30, 40]

C. [10, 20, 30]

D. [30, 40, 50]

Solution

1. Step 1: Understand slicing with skip and limit

   With skip=2 and limit=3, slice is items[2:5].

2. Step 2: Extract slice from list

   items[2:5] = [30, 40, 50] from the list.

3. Final Answer:

   [30, 40, 50] -> Option D

4. Quick Check:

   items[2:5] = [30, 40, 50] [OK]

Hint: Slice list from skip to skip+limit [OK]

Common Mistakes:

• Confusing skip with page number
• Using limit as end index instead of length
• Off-by-one errors in slicing

4. Identify the error in this FastAPI pagination endpoint:

@app.get('/users')
def get_users(page: int = 1, size: int = 10):
    skip = page * size
    users = get_all_users()
    return users[skip : skip + size]

medium

A. The calculation of skip should be (page - 1) * size

B. The function should use skip and limit parameters instead of page and size

C. The slice should be users[skip : size] instead of users[skip : skip + size]

D. The default size should be 1, not 10

Solution

1. Step 1: Analyze skip calculation

   Skip should start from zero on page 1, so skip = (page - 1) * size.

2. Step 2: Check slicing correctness

   Current skip calculation skips too many items, causing wrong slice.

3. Final Answer:

   The calculation of skip should be (page - 1) * size -> Option A

4. Quick Check:

   skip = (page - 1) * size [OK]

Hint: Page 1 means skip zero items [OK]

Common Mistakes:

• Using page * size instead of (page - 1) * size
• Confusing slice end index
• Ignoring zero-based indexing

5. You want to create a FastAPI endpoint that returns paginated results along with total count of items. Which of the following code snippets correctly implements this pattern?

hard

A. def get_paginated(page: int = 0, size: int = 10):
data = get_all_data()
skip = (page - 1) * size
return {"total": len(data), "items": data[skip:skip+size]}

B. def get_paginated(skip: int = 0, limit: int = 10):
data = get_all_data()
return {"total": len(data), "items": data[skip:skip+limit]}

C. def get_paginated(offset: int = 0, count: int = 10):
data = get_all_data()
return {"total": len(data), "items": data[offset:count]}

D. def get_paginated(page: int = 1, size: int = 10):
data = get_all_data()
skip = page * size
return {"count": len(data), "results": data[skip:skip+size]}

Solution

1. Step 1: Check pagination calculation

   def get_paginated(skip: int = 0, limit: int = 10): data = get_all_data() return {"total": len(data), "items": data[skip:skip+limit]} correctly uses skip and limit with default values and slices data properly.

2. Step 2: Verify total count and returned keys

   def get_paginated(skip: int = 0, limit: int = 10): data = get_all_data() return {"total": len(data), "items": data[skip:skip+limit]} returns total count and paginated items with clear keys "total" and "items".

3. Final Answer:

   def get_paginated(skip: int = 0, limit: int = 10):\n data = get_all_data()\n return {"total": len(data), "items": data[skip:skip+limit]} -> Option B

4. Quick Check:

   Skip/limit with total count returned [OK]

Hint: Return total count and slice with skip/limit [OK]

Common Mistakes:

• Wrong skip calculation with page * size
• Incorrect slice indices causing empty results
• Using page=0 instead of page=1 for pagination