பக்கிடுதல் (Pagination) பெரிய முடிவுகளின் தொகுப்பைத் தனித்தனி பக்கங்களாகப் பிரிக்கிறது, இதனால் நீங்கள் ஆயிரக்கணக்கான பதிவுகளை ஒரே நேரத்தில் ஏற்றக் கொள்ள மாட்டீர்கள். இது செயல்திறன் மற்றும் பயন்தகத்துக்கு அপরிहार்யம். Django templates/views-க்கு Paginator வர்க்கத்தை வழங்குகிறது, மற்றும் DRF APIs-க்கு உருவாக்கப்பட்ட பக்கிடுதல் வசதிகளை வழங்குகிறது.
articles = Article.objects.()
from django.core.paginator import Paginator
def article_list(request):
articles = Article.objects.all().order_by("-created_at") # ORDER matters for consistent pages
paginator = Paginator(articles, 20) # 20 items per page
page_number = request.GET.get("page") # ?page=2
page_obj = paginator.get_page(page_number) # the requested page
return render(request, "list.html", {"page_obj": page_obj})
<!-- in the template -->
{% for article in page_obj %}
<h2>{{ article.title }}</h2>
{% endfor %}
{% if page_obj.has_previous %}<a href="?page={{ page_obj.previous_page_number }}">Prev</a>{% endif %}
Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}
{% if page_obj.has_next %}<a href="?page={{ page_obj.next_page_number }}">Next</a>{% endif %}
Paginator queryset-ஐ பக்கங்களாக வகுக்கிறது மற்றும் get_page() வழிச்செலுத்தல் உதவிகளைக் கொண்ட ஒரு பக்க பொருளை (பொருளை) திரும்பக் கொடுக்கிறது (has_next, next_page_number, முதலியன) — இது வினவலுக்கு LIMIT/OFFSET-ஐ சேர்க்கிறது, எனவே ডேட்டாபேஸிலிருந்து ஒரே ஒரு பக்கம் பெறப்படுகிறது.
# global default in settings.py
REST_FRAMEWORK = {
"DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.PageNumberPagination",
"PAGE_SIZE": 20,
}
# now list endpoints are automatically paginated, returning:
# { "count": 1000, "next": "...?page=3", "previous": "...?page=1", "results": [...] }
DRF பட்டியல் endpoints-ஐ உள்ளமைக்கப்பட்ட பின் தானாக பக்கிடுகிறது, பக்க metadata (எண்ணிக்கை, அடுத்த/முந்தைய இணைப்புகள்) முடிவுகளோடு வழங்குகிறது — கிளையன்ட்கள் வழங்கப்பட்ட URLs வழியாக வழிச்செலுத்துகின்றனர்.
PageNumberPagination → ?page=2 (simple page numbers)
LimitOffsetPagination → ?limit=20&offset=40 (flexible offsets)
CursorPagination → opaque cursor; consistent & performant for large/changing data
(avoids OFFSET performance issues on huge datasets)
⚠️ OFFSET-based pagination (page/offset) gets SLOWER on deep pages of huge tables
(the DB must skip OFFSET rows). For very large datasets, CURSOR pagination
(keyset, using a WHERE on an indexed column) is far more efficient.
⚠️ Always ORDER BY a stable field, or pages can be inconsistent/repeat items.
பக்கிடுதல் என்பது செயல்திறனுள்ள, பயன்தகமான பயன்பாடுகளை உருவாக்க அপரிहार்யம் — அதில் இல்லாமல், பட்டியல் endpoints மற்றும் முழு அட்டவணைகளை ஏற்றக் கொள்ளும் பக்கங்கள் (சாத்தியமாக ஆயிரங்கள் அல்லது மில்லியன்கள் வரிசைகள்) மெதுவாக, நினைவு-தீவிரம் மற்றும் பயன்தகமற்றதாக மாறுகிறது, இது ডேட்டாபேஸை கடுமையாக்குகிறது மற்றும் பயனர்கள் மற்றும் கிளையன்ட்களை அடக்குகிறது.
பக்கிடுதல் புரிந்துகொள்வது அன்றாட நடைமுறை ஞ்ஞானம்: Django இன் Paginator மரபுவழி views/templates-ஐ கையாளுகிறது (querysets-ஐ பக்கங்களாக வெட்டுதல், வழிச்செலுத்தல் உதவிகளுடன், LIMIT/OFFSET வழியாக ஒரே ஒரு பக்கத்தை திறமையாக பெறுதல்), மற்றும் DRF இன் உருவாக்கப்பட்ட பக்கிடுதல் APIs-ஐ கையாளுகிறது (தனிப்பயனாக பக்கிடுதல் பட்டியல் endpoints-ஐ metadata மற்றும் வழிச்செலுத்தல் இணைப்புகளுடன் உள்ளமைக்கப்பட்ட பின்) — நீங்கள் சேவையக-வழங்கிய பக்கங்களை அல்லது APIs-ஐ உருவாக்குகிறீர்களா என்பதைப் பொறுத்து இரண்டும் தேவையாகின்றன.
இரண்டு சூழ்நிலைகளிலும் பக்கிடுதல் செயல்படுத்த எப்படி என்பது தெரிந்திருப்பது ஏறக்குறைய எந்த ডேட்டா-பட்டியல் அம்சத்திற்கும் அவசியம்.
செயல்திறன் நுணுக்கம் என்பது மிகவும் மূல்யமான மூத்த-நிலை ஞ்ஞானம்: நிலையான OFFSET-அடிப்படை பக்கிடுதல் மிகப்பெரிய அட்டவணைகளின் ஆழமான பக்கங்களில் சரியாகக் கிரியைத்திறன் அழிந்துவிடுகிறது (ডேட்டாபேஸ் முந்தைய அனைத்து வரிசைகளையும் தாண்டிச் செல்ல வேண்டும்), எனவே cursor (keyset) பக்கிடுதல் பিரம்மாண்ড அல்லது விரைவாக மாறும் datasets-க்கான திறமையான தேர்வாகும், மற்றும் எப்போதும் ஒரு நிலையான புலத்தால் வரிசைப்படுத்துதல் பக்கங்களிலுமாறி முறிந்த அல்லது பக்கப்பிரிக்கப்பட்ட முடிவுகளைத் தடுக்க அவசியம்.
மூலக்கூறு பொறிமுறைகள் (Paginator, DRF பக்கிடுதல் வர்க்கங்கள்) மற்றும் இந்த செயல்திறன் பரிசீலनைகள் (OFFSET vs cursor பக்கிடுதல், நிலையான வரிசைப்படுத்துதல்) ஆகிய இரண்டையும் புரிந்துகொள்வது பயன்பாடுகளை உருவாக்க முக்கியமானது — பக்கிடுதல் ஒரு உபிரவமான தேவை, மற்றும் அதை நன்கு செய்வது, குறிப்பாக அளவில், பயன்பாட்டு செயல்திறன் மற்றும் பயனர் அனுபவத்தை நேரடியாக பாதிக்கும் நடைமுறை திறமை.