तपाई कसरी ढिलो डेटाबेस क्वेरी अप्टिमाइज गर्नुहुन्छ?

Question

Accepted Answer

**क्वेरी प्लान सँगै सुरु गर्नुहोस्, त्यसपछी सबैभन्दा ठूलो लागत ठीक गर्नुहोस्।** `EXPLAIN`/`EXPLAIN ANALYZE` प्रयोग गरेर डेटाबेसले वास्तवमा के गर्छ भनी हेर्नुहोस्, सही **indexes** थप्नुहोस्, **N+1** क्वेरीहरू हटाउनुहोस्, र तपाईलाई चाहिने डेटा मात्र चयन गर्नुहोस्।

## क्वेरी प्लान पढ्नुहोस्

`EXPLAIN ANALYZE` ले एक्सिक्यूशन प्लान र वास्तविक टाइमिङ्गहरू देखाउँछ। एक ठूलो टेबलमाथि **Seq Scan** ले क्लासिक रेड फ्ल्याग हो:

```sql
EXPLAIN ANALYZE
SELECT * FROM orders WHERE customer_id = 42;
-- Seq Scan on orders  (cost=0.00..18500 rows=120)
--   Filter: (customer_id = 42)
--   rows removed by filter: 999880   ← scanned the whole table!
```

## सही index थप्नुहोस्

एक index ले पूर्ण स्क्यानलाई द्रुत खोजमा परिणत गर्छ:

```sql
CREATE INDEX idx_orders_customer ON orders (customer_id);
-- Now: Index Scan using idx_orders_customer  (cost=0.42..8.5 rows=120)
--   1,000,000-row scan → ~120-row lookup
```

Indexहरूको **writes मा लागत** छ: हरेक INSERT/UPDATE ले पनि index अपडेट गर्नुपर्छ, त्यसैले तपाई फिल्टर/join/sort गरेको स्तम्भहरूमा index गर्नुहोस् — हरेक स्तम्भमा होइन। एक **composite** index `(customer_id, created_at)` ले `WHERE customer_id = ? ORDER BY created_at` लाई एक संरचनामा सेवा दिन्छ।

## N+1 र over-fetching ठीक गर्नुहोस्

**N+1 समस्या** — एक सूचीको लागि एक क्वेरी, त्यसपछी हरेक पङ्क्तिको लागि एक — ढिलोपनको शीर्ष कारण हो। यसलाई eager loading, एक `JOIN`, वा batched `IN (...)` सँग बदल्नुहोस्:

```sql
-- N+1: 1 + 100 queries
SELECT * FROM orders;            -- then per order: SELECT * FROM users WHERE id = ?

-- Fixed: one JOIN, only needed columns
SELECT o.id, o.total, u.name
FROM orders o JOIN users u ON u.id = o.user_id;
```

पनि **केवल आवश्यक स्तम्भहरू चयन गर्नुहोस्** (avoid `SELECT *`) र **paginate** गर्नुहोस् `LIMIT`/keyset pagination सँग त्यसैले तपाई कहिले पनि लाखौ पङ्क्तिहरू लोड गर्नुहुन्न।

## किन यो महत्वपूर्ण छ

डेटाबेस सबैभन्दा सामान्य बाधा हो। प्लान पढ्नुले तपाईलाई क्वेरी किन ढिलो छ भनी बताउँछ अनुमान गर्नुको सट्टा; सही index, N+1 हटाउनु, र परिणाम सेट ट्रिम गर्नु नियमित रूपमा दोस्रो-लामो क्वेरीहरूलाई मिलिसेकन्डको हरेकमा परिणत गर्छ — हार्डवेयर स्केल गरेबिना।