OFFSET 200 000: nega 10 000-sahifa sekin ochiladi va keyset pagination buni qanday hal qiladi
OFFSET har bir o'tkazib yuborilgan qatorni baribir o'qiydi va yangi yozuv kelganda sahifalarni surib yuboradi. (created_at, id) bo'yicha keyset pagination, base64 cursor, COUNT(*) narxi va Django'da to'liq realizatsiya.
Admin panelda buyurtmalar ro'yxati bor: eng yangilari tepada, har sahifada 20 ta. Birinchi sahifalar bir zumda ochiladi. Keyin kimdir eski buyurtmani qidirib, URL'ga ?page=10000 deb yozadi va sahifa sezilarli sekinlashadi. Shu vaqtning o'zida mobil ilovada foydalanuvchi "yana yuklash" tugmasini bosadi va ro'yxatda o'zi hozirgina ko'rgan buyurtmani yana ko'radi: u varaqlab turgan paytda yangi buyurtma tushgan va hamma qatorlar bittaga pastga surilgan.
Ikkala muammoning ildizi bitta: OFFSET. Bu maqolada uning nega sekinlashishini, keyset (cursor) pagination qanday ishlashini, cursor'ni qanday kodlashni, COUNT(*) narxini va bularning hammasini Django'da qanday yozishni ko'rib chiqamiz.
OFFSET qanday ishlaydi va nega sekinlashadi
Django'dagi Paginator va qs[200000:200020] kabi slice'lar oxir-oqibat shunday SQL'ga aylanadi:
SELECT id, customer_id, amount, created_at
FROM shop_order
ORDER BY created_at DESC, id DESC
LIMIT 20 OFFSET 200000;
Ko'rinishidan PostgreSQL to'g'ridan-to'g'ri 200 001-qatorga "sakraydi"dek tuyuladi. Aslida unday emas. B-tree index'da "N-chi element" degan tushuncha yo'q: index tartiblangan daraxt, unda kalit bo'yicha qidirish mumkin, lekin tartib raqami bo'yicha emas. Shuning uchun executor qatorlarni tartib bilan birma-bir oladi, birinchi 200 000 tasini tashlab yuboradi va keyingi 20 tasini qaytaradi. PostgreSQL hujjatlarida ham ochiq yozilgan: OFFSET o'tkazib yuborgan qatorlar baribir server ichida hisoblanadi, shuning uchun katta OFFSET samarasiz bo'lishi mumkin.
Buni o'zingiz EXPLAIN ANALYZE bilan ko'rishingiz mumkin. Vaqt sizning muhitingizga bog'liq, shuning uchun men uni yozmadim; asosiy narsa actual rows ustunida:
psql -c "EXPLAIN ANALYZE SELECT * FROM shop_order ORDER BY created_at DESC, id DESC LIMIT 20 OFFSET 200000;"
Limit (... rows=20 ...) (actual time=... rows=20 loops=1)
-> Index Scan using order_created_id_desc on shop_order
(... rows=302000 ...) (actual time=... rows=200020 loops=1)
Limit 20 ta qator qaytargan, lekin uning ostidagi Index Scan 200 020 ta qatorni o'qigan. Sahifa raqami oshgan sari ish hajmi chiziqli o'sadi: 10-sahifa arzon, 10 000-sahifa esa qimmat. Agar ORDER BY uchun mos index bo'lmasa, holat yanada yomonroq: PostgreSQL avval jadvalni o'qib, keyin saralashi kerak bo'ladi.
Ikkinchi muammo: sahifalar "suriladi"
Tezlikdan tashqari, OFFSET natijasi barqaror emas. Foydalanuvchi 1-sahifani ko'rdi (1–20-qatorlar). Shu orada 3 ta yangi buyurtma tushdi. U 2-sahifani so'raydi: OFFSET 20. Endi 21–40-o'rinlarda avvalgi 18–37-qatorlar turibdi, ya'ni 3 ta buyurtma ikki marta ko'rinadi. Qator o'chirilsa, aksincha, bitta qator hech qachon ko'rinmay qoladi.
Admin panelda bu shunchaki noqulaylik. Lekin cheksiz scroll'li lentada, yoki undan ham yomoni, sahifalab yurib ma'lumot eksport qiladigan yoki qayta ishlaydigan background job'da bu takrorlangan yoki tushib qolgan yozuvlarni anglatadi.
Keyset pagination: "qayerda to'xtagan bo'lsam, o'shandan keyin"
G'oya oddiy: "N ta qatorni o'tkazib yubor" o'rniga "oxirgi ko'rgan qatorimdan keyingilarini ber" deymiz. Oxirgi qator — bu tartiblash kalitining qiymati. Uni qo'yib yuborishning eng toza usuli PostgreSQL'dagi row comparison (qatorlarni solishtirish):
-- first page
SELECT id, customer_id, amount, created_at
FROM shop_order
ORDER BY created_at DESC, id DESC
LIMIT 21;
-- next page: last row of the previous page was
-- (created_at = '2026-11-03 18:42:07.512301+05', id = 918273)
SELECT id, customer_id, amount, created_at
FROM shop_order
WHERE (created_at, id) < ('2026-11-03 18:42:07.512301+05', 918273)
ORDER BY created_at DESC, id DESC
LIMIT 21;
(created_at, id) < (a, b) ifodasi leksikografik solishtiriladi: avval created_at < a, agar ular teng bo'lsa, id < b. Bu xuddi ORDER BY created_at DESC, id DESC tartibiga mos keladi.
Endi eng muhim qism. (created_at, id) bo'yicha B-tree index bo'lsa, PostgreSQL bu shartni Index Cond sifatida ishlata oladi: daraxtdan kerakli nuqtani topadi va o'sha yerdan 21 ta qatorni o'qiydi. Hech narsa tashlab yuborilmaydi:
Limit (... rows=21 ...) (actual time=... rows=21 loops=1)
-> Index Scan using order_created_id_desc on shop_order
(actual time=... rows=21 loops=1)
Index Cond: (ROW(created_at, id) < ROW('2026-11-03 18:42:07.512301+05'::timestamptz, 918273))
Endi 1-sahifa ham, "10 000-sahifa" ham bir xil ish hajmini talab qiladi: daraxt bo'ylab bitta tushish va LIMIT qadar qator o'qish. Yangi qatorlar qo'shilsa ham, siljish bo'lmaydi: shart "aynan shu qatordan keyin" deydi, "20-o'rindan keyin" emas.
OFFSET "qancha qatorni o'tkazib yuborishni" eslab qoladi, keyset esa "qayerda to'xtaganini". Birinchisi ma'lumot o'zgarganda buziladi, ikkinchisi yo'q.
Bitta qo'shimcha qator (LIMIT 21) keyingi sahifa bor-yo'qligini bilish uchun kerak: 21-qator kelsa, keyingi sahifa bor, uni foydalanuvchiga ko'rsatmaymiz.
Nega ikkinchi kalit shart
Faqat created_at bo'yicha sahifalash jozibali ko'rinadi, lekin bu xato. created_at unique emas: bulk import, bitta transaction ichida yaratilgan bir nechta yozuv (now() transaction boshlangan vaqtni qaytaradi) yoki shunchaki bir xil vaqt belgisi. Agar sahifa chegarasi bir xil created_atli ikki qator orasiga tushsa:
WHERE created_at < :lastikkinchi qatorni yo'qotadi;WHERE created_at <= :lastbirinchisini takrorlaydi.
Yechim: tartibni to'liq qilish, ya'ni oxiriga unique ustun qo'shish. Odatda bu primary key: ORDER BY created_at DESC, id DESC. Shunda har bir qatorning tartibdagi o'rni bir ma'noli va cursor aniq bitta nuqtani ko'rsatadi.
Django'da realizatsiya
Model va index. Index ustunlari tartibi ORDER BY bilan bir xil bo'lishi kerak. B-tree'ni PostgreSQL teskari yo'nalishda ham o'qiy oladi, shuning uchun (created_at, id) index ham ishlaydi; muhimi, ikkala ustunning yo'nalishi bir xil bo'lsin.
# shop/models.py
from django.db import models
class Order(models.Model):
customer_id = models.BigIntegerField()
amount = models.DecimalField(max_digits=12, decimal_places=2)
created_at = models.DateTimeField() # NOT NULL by default
class Meta:
indexes = [
models.Index(fields=["-created_at", "-id"], name="order_created_id_desc"),
]
Endi cursor. Klientga ichki tuzilmani berish shart emas: created_at va idni JSON'ga solib, URL uchun xavfsiz base64 bilan kodlaymiz. Klient uchun bu shunchaki noaniq (opaque) satr: uni keyingi so'rovda qaytarib yuboradi, xolos.
# shop/cursors.py
import base64
import json
from datetime import datetime
class InvalidCursor(ValueError):
pass
def encode_cursor(created_at: datetime, pk: int) -> str:
raw = json.dumps({"c": created_at.isoformat(), "i": pk}, separators=(",", ":"))
return base64.urlsafe_b64encode(raw.encode()).decode().rstrip("=")
def decode_cursor(cursor: str) -> tuple[datetime, int]:
try:
padded = cursor + "=" * (-len(cursor) % 4)
data = json.loads(base64.urlsafe_b64decode(padded))
return datetime.fromisoformat(data["c"]), int(data["i"])
except (ValueError, KeyError, TypeError) as exc:
raise InvalidCursor("bad cursor") from exc
isoformat() mikrosekundlarni ham saqlaydi. Bu muhim: PostgreSQL timestamptz mikrosekund aniqligida saqlaydi, va agar cursor'da millisekundgacha yaxlitlangan vaqt bo'lsa, chegaradagi qatorlar takrorlanadi yoki yo'qoladi. Shuning uchun ham klient cursor'ni o'zi yasamasligi kerak: JavaScript'dagi Date faqat millisekundni biladi.
Sahifa funksiyasi. Django ORM'da row comparison uchun ochiq API yo'q, shuning uchun ekvivalent shartni Q bilan yozamiz:
# shop/pagination.py
from django.db.models import Q
from .cursors import decode_cursor, encode_cursor
from .models import Order
def orders_page(cursor: str | None = None, limit: int = 20):
qs = Order.objects.order_by("-created_at", "-id")
if cursor:
created_at, pk = decode_cursor(cursor)
qs = qs.filter(
Q(created_at__lt=created_at) | Q(created_at=created_at, id__lt=pk),
created_at__lte=created_at, # redundant, but gives the planner an index condition
)
rows = list(qs[: limit + 1]) # one extra row tells us whether a next page exists
has_next = len(rows) > limit
rows = rows[:limit]
next_cursor = encode_cursor(rows[-1].created_at, rows[-1].pk) if has_next else None
return rows, next_cursor
created_at__lte=created_at sharti mantiqan ortiqcha: OR ichidagi ikkala tarmoq ham buni nazarda tutadi. Lekin u planner'ga oddiy oraliq shartini beradi va PostgreSQL uni Index Cond sifatida ishlatadi, OR qismini esa o'qilgan bir nechta qatorga filter sifatida qo'llaydi. Bu shartsiz OR ifodasi uchun planner yaxshi reja topmasligi mumkin, shuning uchun o'z ma'lumotlaringizda EXPLAIN bilan tekshiring.
Agar aynan row comparison kerak bo'lsa, RawSQLni boolean ifoda sifatida filter()ga berish mumkin. Bu yerda jadval nomini qo'lda yozishga to'g'ri keladi, buni yodda tuting:
from django.db.models import BooleanField
from django.db.models.expressions import RawSQL
qs = qs.filter(
RawSQL(
'("shop_order"."created_at", "shop_order"."id") < (%s, %s)',
(created_at, pk),
output_field=BooleanField(),
)
)
View'da yaroqsiz cursor 500 emas, 400 qaytarishi kerak, limit esa cheklangan bo'lishi kerak:
# shop/views.py
from django.http import JsonResponse
from .cursors import InvalidCursor
from .pagination import orders_page
def order_list(request):
try:
limit = max(1, min(int(request.GET.get("limit", 20)), 100))
except ValueError:
limit = 20
try:
rows, next_cursor = orders_page(request.GET.get("cursor"), limit)
except InvalidCursor:
return JsonResponse({"error": "invalid cursor"}, status=400)
return JsonResponse({
"results": [
{"id": o.pk, "amount": str(o.amount), "created_at": o.created_at.isoformat()}
for o in rows
],
"next_cursor": next_cursor,
})
Agar DRF ishlatsangiz, unda tayyor CursorPagination bor va u xuddi shu g'oyaga asoslangan. Lekin uning ham talabi bir xil: tartiblash maydoni o'zgarmas va iloji boricha unique bo'lishi kerak.
Total count: "Jami: 4 812 337 ta" qanchaga tushadi
Django'ning Paginatori sahifalar sonini hisoblash uchun count() chaqiradi, ya'ni har so'rovda SELECT COUNT(*). PostgreSQL'da jadvaldagi qatorlar soni hech qayerda tayyor saqlanmaydi. Sabab MVCC: har transaction o'z snapshot'ini ko'radi va bir vaqtning o'zida ikki transaction uchun "qatorlar soni" turlicha bo'lishi mumkin. Shuning uchun aniq COUNT(*) ko'rinadigan barcha qatorlarni sanab chiqadi. Index-only scan yordam berishi mumkin, lekin baribir hamma qator (index yozuvlari) bo'ylab o'tadi. Ya'ni keyset bilan sahifaning o'zini tezlashtirib, yonidan COUNT(*) qo'shsangiz, sekinlikni shunchaki boshqa joyga ko'chirgan bo'lasiz.
Variantlar:
| Yondashuv | Aniqlik | Narx | Qachon mos |
|---|---|---|---|
COUNT(*) |
aniq | barcha mos qatorlarni o'qiydi | kichik jadval yoki kuchli filter |
pg_class.reltuples |
taxminiy | deyarli bepul | butun jadval, filtersiz |
EXPLAIN bahosi |
taxminiy, ba'zan ancha xato | deyarli bepul | filterli so'rov, "~12 ming" ko'rsatish |
| Count'ni umuman ko'rsatmaslik | — | bepul | cheksiz scroll, API |
-- exact: reads every visible row
SELECT count(*) FROM shop_order;
-- estimate for the whole table: updated by VACUUM / ANALYZE
SELECT reltuples::bigint AS estimate
FROM pg_class
WHERE oid = 'shop_order'::regclass;
reltuples VACUUM, ANALYZE (jumladan autovacuum) va CREATE INDEX paytida yangilanadi. Jadval hali hech qachon tahlil qilinmagan bo'lsa, PostgreSQL 14 va undan yangi versiyalarda u -1 bo'ladi, buni kodda hisobga oling. Filterli so'rov uchun planner bahosini Django'ning o'zidan olish mumkin:
import json
def estimate_count(qs) -> int:
plan = json.loads(qs.order_by().explain(format="json"))
return int(plan[0]["Plan"]["Plan Rows"])
# usage
qs = Order.objects.filter(customer_id=42)
approx = estimate_count(qs)
Bu baho statistikaga asoslanadi va murakkab shartlarda bir necha marta adashishi mumkin. Shuning uchun UI'da uni "taxminan 12 000" deb ko'rsating, aniq son sifatida emas. Ko'p hollarda eng to'g'ri javob esa umuman sanamaslik: "keyingi sahifa bor" degan ma'lumot LIMIT + 1 bilan tekinga keladi.
Production'da uchraydigan tuzoqlar
- Sahifa raqamiga sakrab bo'lmaydi. Keyset faqat "keyingi/oldingi"ni beradi. Agar biznes "47-sahifaga o'tish"ni talab qilsa, bu ko'pincha aslida sana yoki ID bo'yicha filter kerakligini bildiradi: "2025-yil martiga o'tish"
WHERE created_at < '2025-04-01'bilan oson yoziladi. - Oldingi sahifa. Shartni teskari qilasiz (
>), tartibni teskari qilasiz (ORDER BY created_at, id),LIMIT + 1olasiz va natijani Python'da yana teskari aylantirasiz. Buning uchun cursor'da yo'nalishni ham saqlash qulay. - Aralash yo'nalish.
ORDER BY created_at DESC, id ASCuchun(created_at, id) < (...)ishlamaydi: row comparison ikkala ustunni bir yo'nalishda solishtiradi. Bunday holda shartni OR bilan qo'lda yozasiz va index'ni ham(created_at DESC, id ASC)qilib yaratasiz. - NULL.
NULLbilan solishtirish natijasiNULL, va bunday qatorlar shartdan o'tmaydi, ya'ni sahifalashdan butunlay tushib qoladi. Tartiblash ustunlariniNOT NULLqiling yokiCOALESCEbilan ifoda index'i tuzing. - O'zgaruvchan maydon bo'yicha tartiblash.
updated_atyokiscorebo'yicha sahifalasangiz, qator varaqlash davomida boshqa joyga ko'chishi mumkin: bir marta ikki sahifada ko'rinadi yoki umuman ko'rinmaydi. Bu yerda ham keyset OFFSET'dan yaxshiroq, lekin mukammal emas. - Filter va index.
WHERE customer_id = 42qo'shilsa, index ham(customer_id, created_at, id)bo'lishi kerak. Aks holda PostgreSQL boshqa mijozlarning qatorlarini o'qib, filter bilan tashlab yuboradi va siz yana OFFSET'dagi muammoga qaytasiz. - Cursor ishonchli ma'lumot emas. Base64 shifrlash emas, uni har kim ochib o'zgartira oladi. Odatda bu xavfli emas, chunki cursor faqat pozitsiya, ruxsat tekshiruvi esa queryset'ning o'zida bo'lishi kerak. Agar cursor'ga filterlarni ham joylasangiz, uni
django.core.signingbilan imzolang. - Background job'lar. Katta jadvalni bo'laklab qayta ishlashda
OFFSETemas,WHERE id > :last_id ORDER BY id LIMIT 1000ishlating: bu keyset'ning eng oddiy ko'rinishi.
Qisqa checklist
ORDER BYoxirida unique ustun (odatdaid) bormi?ORDER BYustunlariga, shu tartib va yo'nalishda, index bormi? Filter ustunlari index boshida turibdimi?EXPLAIN ANALYZEda shartIndex Condsifatida ko'rinyaptimi vaactual rowsLIMITga yaqinmi?- Cursor opaque (base64), mikrosekundlar saqlanadi, yaroqsiz cursor 400 qaytaradi.
limityuqoridan cheklangan, keyingi sahifaLIMIT + 1bilan aniqlanadi.- Tartiblash ustunlari
NOT NULL. - Katta jadvalda aniq
COUNT(*)o'rniga taxminiy son yoki umuman count yo'q.
Xulosa
OFFSET kichik jadvallar va birinchi bir necha sahifa uchun yaxshi, lekin u o'tkazib yuborilgan har bir qator uchun to'laydi va ma'lumot o'zgarganda sahifalarni surib yuboradi. Keyset pagination tartibni to'liq qiladigan kalit va mos index bilan har bir sahifani bir xil narxda beradi. Cursor'ni opaque qiling, COUNT(*)ni esa faqat haqiqatan kerak bo'lganda va iloji bo'lsa taxminiy holda ishlating.
// izohlar
Izohlar yuklanmoqda...