మీరు నెమ్మదిగా ఉన్న డేటాబేస్ ప్రశ్న ఎలా ఆప్టిమైజ్ చేస్తారు?

Question

Accepted Answer

**ప్రశ్న ప్రణాళికతో ప్రారంభించండి, ఆపై అతిపెద్ద ఖర్చును సరిచేయండి.** డేటాబేస్ వాస్తవానికి ఏమి చేస్తుందో చూడటానికి `EXPLAIN`/`EXPLAIN ANALYZE` ఉపయోగించండి, సరైన **సూచికలను** జోడించండి, **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!
```

## సరైన సూచికను జోడించండి

సూచిక పూర్ణ స్కాన్‌ను వేగవంతమైన లుకప్‌గా మారుస్తుంది:

```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
```

సూచికలు **రైట్‌లలో ఖర్చు** కలిగి ఉన్నాయి: ప్రతి INSERT/UPDATE సూచికను కూడా నవీకరించాలి, కాబట్టి మీరు ఫిల్టర్/జాయిన్/సార్ట్ చేసే నిలువు వరుసలను ఇండెక్స్ చేయండి — ప్రతి నిలువు వరుస కాదు. **కాంపోజిట్** సూచిక `(customer_id, created_at)` ఒక నిర్మాణంలో `WHERE customer_id = ? ORDER BY created_at` సేవ చేస్తుంది.

## N+1 మరియు over-fetching ని సరిచేయండి

**N+1 సమస్య** — జాబితా కోసం ఒక ప్రశ్న, ఆపై ప్రతి వరుసకు ఒకటి — నెమ్మదికి ప్రధాన కారణం. దీన్ని తీవ్ర లోడింగ్, `JOIN`, లేదా బ్యాచ్ `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;
```

కూడా **అవసరమైన నిలువు వరుసలను మాత్రమე ఎంచుకోండి** (`SELECT *` నుండి తప్పుకోండి) మరియు **పేజినేట్** చేయండి `LIMIT`/keyset pagination ఉపయోగించి మీరు ఎప్పటికీ లక్షల వరుసలను లోడ్ చేయవద్దు.

## ఇది ఎందుకు ముఖ్యమైనది

డేటాబేస్ అత్యంత సాధారణ గడ్డకట్టు. ప్రణాళికను చదవడం ఒక ప్రశ్న ఎందుకు నెమ్మదిగా ఉందో చెబుతుంది అంచనా వేయటానికి బదులుగా; సరైన సూచిక, N+1 తీసివేయడం, మరియు ఫలితం సెట్ ట్రిమ్ చేయడం దశలను సెకన్ల ప్రశ్నలను మిల్లీసెకన్‌లుగా మారుస్తుంది — హార్డ్‌వేర్‌ను స్కేల్ చేయకుండా.