પ્રશ્ન યોજના સાથે શરૂ કરો, પછી સૌથી મોટું ખર્ચ ઠીક કરો। EXPLAIN/ નો ઉપયોગ કરો કે ડેટાબેસ વાસ્તવમાં શું કરે છે તે જોવા માટે, સાચી ઉમેરો, પ્રશ્નો દૂર કરો, અને માત્ર જે ડેટાની જરૂર છે તે જ પસંદ કરો.
પ્રશ્ન યોજના સાથે શરૂ કરો, પછી સૌથી મોટું ખર્ચ ઠીક કરો। EXPLAIN/ નો ઉપયોગ કરો કે ડેટાબેસ વાસ્તવમાં શું કરે છે તે જોવા માટે, સાચી ઉમેરો, પ્રશ્નો દૂર કરો, અને માત્ર જે ડેટાની જરૂર છે તે જ પસંદ કરો.
EXPLAIN ANALYZEEXPLAIN ANALYZE એક્સિક્યુશન યોજના અને વાસ્તવિક સમયતાલ બતાવે છે. મોટી ટેબલ પર Seq Scan એ કલાસિક લાલ ઝંડો છે:
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 સંપૂર્ણ સ્કેનને ઝડપી લુકઅપમાં ફેરવે છે:
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
Indexes નો લખવાનો ખર્ચ છે: દરેક INSERT/UPDATE એ પણ index અપડેટ કરવો જોઈએ, તેથી તમે જે કॉલમ પર ફિલ્ટર/join/sort કરો તે પર index લગાવો — દરેક કૉલમ પર નહીં. એક composite index (customer_id, created_at) એક માળખામાં WHERE customer_id = ? ORDER BY created_at ને પૂરો પાડે છે.
N+1 સમસ્યા — એક સૂચી માટે એક પ્રશ્ન, પછી પ્રતિ પંક્તિ એક — ધીમાપણાનો મુખ્ય કારણ છે. તેને eager loading, JOIN, અથવા batched IN (...) સાથે બદલો:
-- 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 સાથે તેથી તમે લાખો પંક્તિઓ ક્યારે જ લોડ કરતા નથી.
ડેટાબેસ સૌથી સામાન્ય bottleneck છે. યોજના વાંચવું તમને કહે છે કેમ પ્રશ્ન ધીમો છે અને અનુમાન કરવા ને બદલે; સાચી index, N+1 દૂર કરવું, અને પરિણામ સમૂહને ટ્રિમ કરવું નિયમિતપણે બીજા-લાંબા પ્રશ્નોને મિલિસેકન્ડમાં ફેરવે છે — હાર્ડવેર સ્કેલ કર્યા વિના.