HarborDB प्रदर्शन अनुकूलन गाइड में आपका स्वागत है। यह व्यापक संसाधन आपको अपने PostgreSQL वर्कफ़्लो के हर पहलू को अनुकूलित करने में मदद करेगा, कुशल क्वेरी लिखने से लेकर अधिकतम प्रदर्शन के लिए HarborDB और macOS को कॉन्फ़िगर करने तक।

प्रदर्शन कारकों को समझना

कई कारक HarborDB में आपके डेटाबेस प्रदर्शन को प्रभावित करते हैं:

| कारक | प्रभाव | अनुकूलन स्तर | | -------------------------- | ----------- | ----------------- | | क्वेरी डिज़ाइन | उच्च | एप्लिकेशन | | डेटाबेस इंडेक्स | उच्च | डेटाबेस | | नेटवर्क कनेक्शन | मध्यम | इन्फ्रास्ट्रक्चर | | सिस्टम संसाधन | मध्यम | macOS | | HarborDB सेटिंग्स | निम्न-मध्यम | एप्लिकेशन | | PostgreSQL कॉन्फ़िगरेशन | उच्च | डेटाबेस |

क्वेरी अनुकूलन

कुशल क्वेरी लिखना

1. केवल आवश्यक चुनें

-- ❌ अक्षम
SELECT * FROM customers;

-- ✅ कुशल
SELECT customer_id, name, email FROM customers;

2. WHERE क्लॉज का प्रभावी ढंग से उपयोग करें

-- ❌ अक्षम (पूर्ण टेबल स्कैन)
SELECT * FROM orders
WHERE EXTRACT(YEAR FROM order_date) = 2024;

-- ✅ कुशल (इंडेक्स का उपयोग करता है)
SELECT * FROM orders
WHERE order_date >= '2024-01-01'
  AND order_date < '2025-01-01';

3. परिणाम सेट सीमित करें

-- एक्सप्लोर करते समय हमेशा सीमित करें
SELECT * FROM large_table LIMIT 100;

-- बड़े परिणामों के लिए पेजिनेशन का उपयोग करें
SELECT * FROM products
ORDER BY created_at DESC
LIMIT 50 OFFSET 0;

4. N+1 क्वेरी समस्याओं से बचें

-- ❌ अक्षम (एकाधिक क्वेरी)
-- पहली क्वेरी: SELECT * FROM orders WHERE status = 'pending'
-- फिर प्रत्येक ऑर्डर के लिए: SELECT * FROM customers WHERE customer_id = ?

-- ✅ कुशल (JOIN के साथ एकल क्वेरी)
SELECT o.*, c.name, c.email
FROM orders o
JOIN customers c ON o.customer_id = c.customer_id
WHERE o.status = 'pending';

क्वेरी विश्लेषण के लिए EXPLAIN का उपयोग करना

HarborDB क्वेरी प्रदर्शन का विश्लेषण करना आसान बनाता है:

अपनी क्वेरी लिखें एडिटर में
टूलबार में "Explain" (⚡) पर क्लिक करें
निष्पादन योजना की समीक्षा करें परिणाम पैन में

EXPLAIN आउटपुट को समझना

Seq Scan: पूर्ण टेबल स्कैन (बड़ी टेबल के लिए अक्सर धीमा)
Index Scan: इंडेक्स का उपयोग करना (आमतौर पर तेज़)
Nested Loop: टेबल जोड़ना (जांचें कि उपयुक्त है या नहीं)
लागत अनुमान: उच्च संख्याएं अधिक कार्य का मतलब

सामान्य अनुकूलन पैटर्न

-- लापता इंडेक्स सुझाव जोड़ें
EXPLAIN ANALYZE
SELECT * FROM orders WHERE customer_id = 1234;

-- परिणाम दिखा सकता है: "Seq Scan on orders"
-- समाधान: CREATE INDEX idx_orders_customer_id ON orders(customer_id);

डेटाबेस इंडेक्स अनुकूलन

कब इंडेक्स जोड़ें

इनके लिए इंडेक्स जोड़ें:

प्राथमिक कुंजी (स्वचालित रूप से इंडेक्स किया गया)
फॉरेन की (अक्सर मैनुअल इंडेक्सिंग की आवश्यकता होती है)
अक्सर फ़िल्टर किए गए कॉलम
अक्सर सॉर्ट किए गए कॉलम
JOIN शर्तों में उपयोग किए गए कॉलम

प्रभावी इंडेक्स बनाना

-- एकल कॉलम इंडेक्स
CREATE INDEX idx_orders_status ON orders(status);

-- मल्टी-कॉलम इंडेक्स (क्रम मायने रखता है!)
CREATE INDEX idx_orders_date_status ON orders(order_date, status);

-- आंशिक इंडेक्स (विशिष्ट सबसेट के लिए)
CREATE INDEX idx_active_users ON users(email) WHERE active = true;

-- कंस्ट्रेंट के लिए यूनिक इंडेक्स
CREATE UNIQUE INDEX idx_unique_email ON users(email);

इंडेक्स रखरखाव

-- इंडेक्स उपयोग जांचें
SELECT schemaname, tablename, indexname
FROM pg_stat_user_indexes
WHERE idx_scan = 0;  -- कभी उपयोग नहीं किए गए इंडेक्स

-- खंडित इंडेक्स पुनर्निर्माण करें
REINDEX INDEX idx_orders_status;

-- क्वेरी प्लानर के लिए आंकड़े अपडेट करें
ANALYZE orders;

कनेक्शन अनुकूलन

कनेक्शन पूल सेटिंग्स

अपने HarborDB कनेक्शन अनुकूलित करें:

वरीयताएं खोलें → कनेक्शन
अपने वर्कफ़्लो के आधार पर सेटिंग्स समायोजित करें:

| सेटिंग | अनुशंसित मान | उद्देश्य | | --------------------- | ----------------- | --------------------------- | | कनेक्शन टाइमआउट | 30 सेकंड | लटके कनेक्शन रोकें | | कीप-अलाइव | सक्षम | निष्क्रिय कनेक्शन बनाए रखें | | अधिकतम कनेक्शन | 5-10 | प्रदर्शन/मेमोरी संतुलन | | SSL मोड | प्राथमिकता | ओवरहेड के बिना सुरक्षित |

नेटवर्क अनुकूलन

रिमोट डेटाबेस के लिए:

सुरक्षित, अनुकूलित कनेक्शन के लिए SSH टनलिंग का उपयोग करें
बड़े परिणाम सेट के लिए संपीड़न सक्षम करें
भारी क्वेरी शेड्यूल करें ऑफ-पीक घंटों के दौरान
अंतर्निहित टूल के साथ नेटवर्क विलंबता की निगरानी करें

-- नेटवर्क विलंबता परीक्षण
SELECT 1 as test;  -- राउंड-ट्रिप समय मापने के लिए सरल क्वेरी

HarborDB प्रदर्शन सेटिंग्स

मेमोरी प्रबंधन

वरीयताएं → प्रदर्शन में मेमोरी उपयोग समायोजित करें:

| सेटिंग | अनुशंसा | प्रभाव | | -------------------- | -------------- | ----------------------------- | | क्वेरी कैश | 256 MB | दोहराई गई क्वेरी तेज़ | | परिणाम सेट मेमोरी | 512 MB | बड़े डेटासेट संभालें | | स्ट्रीमिंग मोड | सक्षम | बड़े परिणामों के लिए बेहतर | | ऑटो-रिफ्रेश | 30 सेकंड | ताजगी/प्रदर्शन संतुलन |

इंटरफेस अनुकूलन

वरीयताएं → रूप में एनिमेशन अक्षम करें
ऑटो-कम्पलीट विलंब 100ms तक कम करें
साइडबार ऑटो-विस्तार गहराई सीमित करें
OLED डिस्प्ले दक्षता के लिए डार्क मोड का उपयोग करें

गति के लिए कीबोर्ड शॉर्टकट

इन उत्पादकता बढ़ाने वाले में महारत हासिल करें:

| शॉर्टकट | क्रिया | समय बचाया | | ------- | -------------- | -------------- | | ⌘ + R | क्वेरी निष्पादित करें | 2-3 सेकंड | | ⌘ + . | क्वेरी रद्द करें | प्रतीक्षा रोकता है | | ⌘ + T | नई क्वेरी टैब | 1-2 सेकंड | | ⌘ + S | क्वेरी सहेजें | 1 सेकंड | | ⌘ + E | परिणाम निर्यात करें | 2 सेकंड | | ⌘ + F | क्वेरी में खोजें | 3-5 सेकंड |

macOS सिस्टम अनुकूलन

हार्डवेयर विचार

मेमोरी (RAM)

न्यूनतम: बेसिक उपयोग के लिए 8 GB
अनुशंसित: पेशेवर काम के लिए 16 GB
इष्टतम: बड़े डेटासेट के लिए 32 GB

स्टोरेज (SSD)

न्यूनतम: 256 GB खाली स्थान
अनुशंसित: डेटाबेस फ़ाइलों और निर्यात के लिए 512 GB+
बड़े डेटाबेस स्टोरेज के लिए एक्सटर्नल SSD का उपयोग करें

प्रोसेसर

Apple Silicon: M1/M2/M3 अनुकूलित
Intel: i5 न्यूनतम, i7/i9 अनुशंसित

macOS सेटिंग्स

ऊर्जा सेवर (सिस्टम वरीयताएं):
- "हार्ड डिस्क को स्लीप करें" अक्षम करें
- लंबी क्वेरी के दौरान डिस्प्ले चालू रखें
गतिविधि मॉनिटर:
- HarborDB मेमोरी उपयोग की निगरानी करें
- PostgreSQL प्रक्रिया संसाधन जांचें
डिस्क उपयोगिता:
- सुनिश्चित करें कि SSD TRIM सक्षम है
- डिस्क स्वास्थ्य और खाली स्थान की निगरानी करें

टर्मिनल प्रदर्शन कमांड

# सिस्टम संसाधन जांचें
top -o cpu  # CPU उपयोग
vm_stat     # मेमोरी उपयोग
iostat      # डिस्क I/O

# विशेष रूप से HarborDB की निगरानी करें
ps aux | grep HarborDB
lsof -p $(pgrep HarborDB) | wc -l  # खुली फ़ाइलें

बड़े डेटासेट रणनीतियाँ

लाखों पंक्तियों के साथ काम करना

1. सर्वर-साइड पेजिनेशन

-- सभी पंक्तियों को लोड करने के बजाय
SELECT * FROM huge_table;

-- पेजिनेशन का उपयोग करें
SELECT * FROM huge_table
ORDER BY id
LIMIT 1000 OFFSET 0;

-- अगला पेज
SELECT * FROM huge_table
ORDER BY id
LIMIT 1000 OFFSET 1000;

2. स्ट्रीमिंग परिणाम

वरीयताएं → प्रदर्शन में सक्षम करें:

✅ "10,000 से अधिक पंक्तियों के लिए स्ट्रीमिंग सक्षम करें"
✅ "स्ट्रीम चंक साइज़: 1000 पंक्तियाँ"
✅ "बैकग्राउंड स्ट्रीमिंग: सक्षम"

3. मटेरियलाइज्ड व्यू

-- महंगी क्वेरी पूर्व-गणना करें
CREATE MATERIALIZED VIEW daily_sales_summary AS
SELECT
    DATE(order_date) as day,
    COUNT(*) as orders,
    SUM(total) as revenue
FROM orders
GROUP BY DATE(order_date);

-- समय-समय पर रीफ्रेश करें
REFRESH MATERIALIZED VIEW daily_sales_summary;

निर्यात अनुकूलन

बड़े निर्यात के लिए:

CSV में निर्यात करें (JSON की तुलना में अधिक कुशल)
चंक्ड निर्यात का उपयोग करें (वरीयताएं → निर्यात)
निर्यात स्वचालित रूप से संपीड़ित करें
सीधे बाहरी स्टोरेज में निर्यात करें

प्रदर्शन की निगरानी

अंतर्निहित HarborDB टूल

क्वेरी टाइमर: स्थिति बार में निष्पादन समय दिखाता है
मेमोरी मॉनिटर: विंडो → प्रदर्शन मॉनिटर में देखें
कनेक्शन स्थिति: रियल-टाइम नेटवर्क मेट्रिक्स
क्वेरी इतिहास: पिछली क्वेरी प्रदर्शन की समीक्षा करें

PostgreSQL मॉनिटरिंग क्वेरी

-- सक्रिय क्वेरी
SELECT
    pid,
    usename,
    query_start,
    state,
    query
FROM pg_stat_activity
WHERE state != 'idle'
ORDER BY query_start DESC;

-- धीमी क्वेरी
SELECT
    query,
    calls,
    total_time,
    mean_time,
    rows
FROM pg_stat_statements
ORDER BY mean_time DESC
LIMIT 10;

-- टेबल आंकड़े
SELECT
    schemaname,
    relname,
    seq_scan,
    idx_scan,
    n_tup_ins,
    n_tup_upd,
    n_tup_del
FROM pg_stat_user_tables
ORDER BY seq_scan DESC;

सामान्य प्रदर्शन समस्याएं और समाधान

समस्या: "क्वेरी बहुत लंबी लेती है"

समाधान चेकलिस्ट:

[ ] उपयुक्त इंडेक्स जोड़ें
[ ] क्वेरी अधिक कुशल बनाने के लिए फिर से लिखें
[ ] PostgreSQL कॉन्फ़िगरेशन जांचें
[ ] नेटवर्क कनेक्टिविटी सत्यापित करें
[ ] आवश्यक हो तो टाइमआउट सेटिंग्स बढ़ाएं

समस्या: "HarborDB बहुत अधिक मेमोरी का उपयोग करता है"

समाधान चरण:

क्वेरी कैश साइज़ कम करें (वरीयताएं → प्रदर्शन)
अप्रयुक्त क्वेरी टैब बंद करें
समय-समय पर HarborDB पुनः आरंभ करें
मेमोरी लीक के लिए जांचें (गतिविधि मॉनिटर)
सीमा लगातार पहुँचने पर सिस्टम RAM बढ़ाएं

समस्या: "निर्यात/आयात बहुत धीमा है"

अनुकूलन टिप्स:

JSON के बजाय CSV प्रारूप का उपयोग करें
लक्ष्य फ़ोल्डर पर एंटीवायरस स्कैनिंग अक्षम करें
HDD के बजाय SSD में निर्यात करें
बहुत बड़े ऑपरेशन के लिए PostgreSQL मूल टूल (pg_dump/pg_restore) का उपयोग करें
बड़े ऑपरेशन को छोटे बैच में विभाजित करें

समस्या: "इंटरफेस सुस्त लगता है"

त्वरित समाधान:

बहुत बड़ी क्वेरी के लिए सिंटेक्स हाइलाइटिंग अक्षम करें
साइडबार ऑटो-विस्तार कम करें
सरल UI थीम का उपयोग करें
अन्य संसाधन-गहन अनुप्रयोग बंद करें
HarborDB और macOS पुनः आरंभ करें

उन्नत अनुकूलन तकनीक

बड़ी टेबल का पार्टीशनिंग

-- पार्टीशन की गई टेबल बनाएं
CREATE TABLE orders_partitioned (
    order_id BIGSERIAL,
    order_date DATE NOT NULL,
    customer_id INT,
    total DECIMAL(10,2)
) PARTITION BY RANGE (order_date);

-- पार्टीशन बनाएं
CREATE TABLE orders_2024_q1 PARTITION OF orders_partitioned
    FOR VALUES FROM ('2024-01-01') TO ('2024-04-01');

CREATE TABLE orders_2024_q2 PARTITION OF orders_partitioned
    FOR VALUES FROM ('2024-04-01') TO ('2024-07-01');

क्वेरी प्लान संकेत

-- इंडेक्स उपयोग बल दें (सावधानी से उपयोग करें)
SET enable_seqscan = off;

-- अस्थायी रूप से कार्य मेमोरी बढ़ाएं
SET work_mem = '64MB';

-- विशिष्ट जॉइन विधि का उपयोग करें
SET enable_nestloop = off;
SET enable_hashjoin = on;

PGBouncer के साथ कनेक्शन पूलिंग

उच्च-समवर्ती अनुप्रयोगों के लिए:

PGBouncer स्थापित करें (Homebrew: brew install pgbouncer)
लेन-देन पूलिंग के लिए कॉन्फ़िगर करें
HarborDB को PGBouncer के माध्यम से कनेक्ट करें
कनेक्शन पुन: उपयोग आंकड़े निगरानी करें

प्रदर्शन परीक्षण

बेंचमार्क क्वेरी बनाना

-- क्वेरी प्रदर्शन परीक्षण
EXPLAIN ANALYZE
SELECT * FROM orders
WHERE order_date BETWEEN '2024-01-01' AND '2024-12-31'
  AND status = 'completed'
ORDER BY total DESC
LIMIT 100;

-- विभिन्न दृष्टिकोणों के साथ तुलना करें
EXPLAIN ANALYZE
SELECT * FROM orders
WHERE status = 'completed'
  AND order_date >= '2024-01-01'
  AND order_date <= '2024-12-31'
ORDER BY total DESC
LIMIT 100;

समय के साथ निगरानी

प्रदर्शन लॉग टेबल बनाएं:

CREATE TABLE query_performance_log (
    log_id SERIAL PRIMARY KEY,
    query_hash TEXT,
    execution_time_ms INTEGER,
    row_count INTEGER,
    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    notes TEXT
);

-- धीमी क्वेरी लॉग करें
INSERT INTO query_performance_log
    (query_hash, execution_time_ms, row_count, notes)
SELECT
    md5(query),
    EXTRACT(MILLISECONDS FROM NOW() - query_start),
    result_rows,
    'धीमी क्वेरी पाई गई'
FROM pg_stat_activity
WHERE state = 'active'
  AND NOW() - query_start > INTERVAL '5 seconds';

सर्वोत्तम अभ्यास सारांश

दैनिक वर्कफ़्लो

नई जटिल क्वेरी के लिए EXPLAIN से शुरू करें
डेटा एक्सप्लोर करते समय LIMIT का उपयोग करें
अप्रयुक्त कनेक्शन बंद करें
नियमित रूप से HarborDB पुनः आरंभ करें (साप्ताहिक)
भारी काम के दौरान सिस्टम संसाधनों की निगरानी करें

साप्ताहिक रखरखाव

क्वेरी प्रदर्शन लॉग की समीक्षा करें
अप्रयुक्त इंडेक्स के लिए जांचें
PostgreSQL आंकड़े अपडेट करें (ANALYZE)
अस्थायी फ़ाइलें साफ़ करें
प्रदर्शन कॉन्फ़िगरेशन बैकअप लें

मासिक समीक्षा

धीमी क्वेरी पैटर्न का विश्लेषण करें
विकास के लिए टेबल पार्टीशनिंग पर विचार करें
हार्डवेयर आवश्यकताओं की समीक्षा करें
HarborDB और PostgreSQL अपडेट करें
प्रदर्शन सुधार दस्तावेज़ करें

सहायता प्राप्त करना

प्रदर्शन ट्यूनिंग सपोर्ट

यदि आपको अतिरिक्त मदद की आवश्यकता है:

क्वेरी योजनाएं हमारी सपोर्ट टीम के साथ साझा करें
प्रदर्शन लॉग निर्यात करें (वरीयताएं → लॉग निर्यात करें)
सिस्टम विनिर्देश शामिल करें (macOS संस्करण, RAM, स्टोरेज)
अपने वर्कफ़्लो और विशिष्ट डेटासेट आकार का वर्णन करें

प्रदर्शन अनुकूलन गाइड