ORDER BY और LIMIT कैसे काम करते हैं, और आप pagination कैसे करते हैं?

Question

Accepted Answer

**`ORDER BY`** परिणाम rows को sort करता है; **`LIMIT`** (`OFFSET` के साथ) यह सीमित करता है कि कितनी rows लौटाई जाएँ। साथ में ये sorting और pagination संभालते हैं — ordered, paged data प्रदर्शित करने के लिए आवश्यक।

## ORDER BY — sorting

```sql
SELECT name, age FROM users ORDER BY age;            -- ascending (default)
SELECT name, age FROM users ORDER BY age DESC;        -- descending
SELECT * FROM users ORDER BY country, name;           -- by country, then name (tie-break)
SELECT * FROM users ORDER BY created_at DESC NULLS LAST;  -- control NULL placement
```

`ORDER BY` एक या अधिक columns द्वारा sort करता है, ascending (default) या `DESC`। कई columns tie-breaking प्रदान करते हैं (पहले द्वारा sort करें, फिर समान मानों के लिए दूसरे द्वारा)।

## LIMIT और OFFSET — सीमित करना और paging

```sql
SELECT * FROM users ORDER BY name LIMIT 10;            -- the first 10 rows
SELECT * FROM users ORDER BY name LIMIT 10 OFFSET 20;  -- skip 20, take 10 (page 3)
-- (syntax varies: MySQL/Postgres use LIMIT/OFFSET; SQL Server uses TOP / OFFSET-FETCH)
```

`LIMIT n` अधिकतम `n` rows लौटाता है; `OFFSET m` पहली `m` को छोड़ता है। साथ में वे **offset pagination** लागू करते हैं (page N = `LIMIT pageSize OFFSET (N-1)*pageSize`)।

## pagination करते समय हमेशा ORDER BY करें

```sql
-- ❌ LIMIT without ORDER BY → row order is UNDEFINED (inconsistent pages!)
SELECT * FROM users LIMIT 10;
-- ✅ always ORDER BY a stable column for consistent pagination
SELECT * FROM users ORDER BY id LIMIT 10;
```

**महत्वपूर्ण:** `ORDER BY` के बिना, database किसी भी order में rows लौटा सकता है, इसलिए pages overlap हो सकते हैं या rows छोड़ सकते हैं। pagination करते समय हमेशा एक stable column द्वारा sort करें।

## OFFSET pagination deep pages पर धीमा हो जाता है

```text
⚠️ LIMIT 10 OFFSET 1000000 — the DB must SKIP a million rows first (slow on deep pages).
For large datasets, KEYSET (cursor) pagination is far more efficient:
  WHERE id > :last_seen_id ORDER BY id LIMIT 10   -- uses an index, no skipping
```

## यह क्यों महत्वपूर्ण है

`ORDER BY` और `LIMIT` data को उपयोगी, प्रबंधनीय तरीके से प्रदर्शित करने के लिए मूलभूत हैं — परिणामों को sort करना और पूरी tables के बजाय pages लौटाना लगभग सार्वभौमिक आवश्यकता है (किसी application में कोई भी list, table, या feed), इसलिए इन्हें समझना आवश्यक रोज़मर्रा का ज्ञान है। `ORDER BY` (एक या अधिक columns द्वारा sorting, tie-breaking के साथ) data को सार्थक order में प्रस्तुत करने के लिए आवश्यक है, और `LIMIT`/`OFFSET` **pagination** लागू करते हैं (data के प्रबंधनीय pages लौटाना) — दोनों applications में सर्वव्यापी।

दो व्यावहारिक बिंदु विशेष रूप से महत्वपूर्ण हैं: **pagination करते समय हमेशा `ORDER BY` का उपयोग करें** (इसके बिना, row order undefined है, जो inconsistent pages पैदा करता है जो overlap होते हैं या rows छोड़ते हैं — एक वास्तविक, आम bug), और यह समझना कि **OFFSET pagination deep pages पर बिगड़ता है** (database को सभी पूर्ववर्ती rows छोड़नी होती हैं, बड़े offsets के लिए धीमा होते हुए), इसलिए **keyset/cursor pagination** (`WHERE id > last_seen`) बड़े datasets के लिए कहीं अधिक कुशल है — performance के लिए मूल्यवान ज्ञान।

चूँकि sorting और pagination लगभग किसी भी data प्रदर्शन के लिए आवश्यक हैं, और चूँकि consistency आवश्यकता (stable pagination के लिए ORDER BY) और performance विचार (बड़े data के लिए OFFSET बनाम keyset) सीधे शुद्धता और गति को प्रभावित करते हैं, इसलिए `ORDER BY` और `LIMIT` में महारत हासिल करना — sorting, offset pagination, stable-ordering आवश्यकता, और scale के लिए keyset विकल्प — data को प्रभावी ढंग से प्रस्तुत करने वाले applications बनाने के लिए मूलभूत, बार-बार उपयोग होने वाला ज्ञान है।