मापा गया, वादा नहीं

गति डिज़ाइन में है, हार्डवेयर में नहीं।

लोड को तेज़ करने के आम तरीके हैं बड़ी मशीन या कम जाँचें। Nodwise को इनमें से किसी की ज़रूरत नहीं: हर नोड बंद व्याकरण के विरुद्ध जाँचा जाता है, उसी बेस कॉन्फ़िगरेशन पर जिस पर हमारी सेवा चलती है।

23.6 मिनट

21,13,664 नोड ख़ाली से लोड करने में

28 मिनट

सब कुछ दोबारा पढ़ने में, खोज अद्यतन

3%

पहले लोड का जाँच में लगा हिस्सा

हमारी बात पर भरोसा न करें

आज आप जिस टूल का उपयोग करते हैं, उसमें आपके वेयरहाउस का लीनेज लोड होने में कितना समय लगता है?

हम आपसे यह नहीं कहेंगे कि हम ज़्यादा तेज़ हैं। समय मापिए। जो लीनेज आपके पास पहले से है, उसे अपने मौजूदा टूल में जाँचें चालू रखकर लोड कीजिए, और उस संख्या को हमारी संख्या के बगल में रखिए। आपका डेटा, आपका फ़ॉर्मेट, आपका टूल — हम अपने टेस्ट का स्वरूप प्रकाशित करते हैं ताकि आप बराबरी की चीज़ों की तुलना कर सकें।

आपका रन

लोड करते समय, क्या आपके टूल ने…

आपका टूल

—

मिनट प्रति दस लाख नोड

Nodwise

11.2

मिनट प्रति दस लाख नोड, 21 लाख पर

4 में से 4 जाँचें

अपनी संख्याएँ लिखिए। मिलते-जुलते आकार पर तुलना कीजिए — किसी भी स्टोर के बढ़ने के साथ प्रति नोड लागत बढ़ती है — और दोनों ओर समान जाँचों के साथ।

हमारा आँकड़ा: 21,13,664 नोड, 63 लाख गुण मान और 42 लाख संबंध, ख़ाली से पहला लोड, अक्टूबर 2026 में एक रन, उसी बेस कॉन्फ़िगरेशन पर जिस पर हमारी सेवा चलती है। आप यहाँ जो भी लिखते हैं, वह आपके ब्राउज़र से बाहर नहीं जाता।

टेस्ट का स्वरूप

कोई समय तब तक कुछ नहीं बताता, जब तक यह न पता हो कि उसे किस स्वरूप पर मापा गया।

टेस्ट एक डेटा कैटलॉग है: स्कीमा जिनमें तालिकाएँ हैं, तालिकाएँ जिनमें कॉलम हैं, और हर कॉलम से अगले स्कीमा के एक कॉलम तक लीनेज। एक समृद्ध स्वरूप — प्रति नोड ज़्यादा गुण, गुण रखने वाले संबंध, ज़िम्मेदारियाँ — ज़्यादा महँगा पड़ता है। इस स्वरूप से तुलना कीजिए, सुर्ख़ी से नहीं।

नोड प्रकार

नोड

गुण मान

संबंध

स्कीमा

128

128

16 384

तालिका

16 384

16 384

2 097 152

कॉलम

विवरण, डेटा प्रकार, प्राइमरी की

2 097 152

6 291 456

2 080 768

कुल

2 113 664

6 307 968

4 194 304

जाँचा गया

हर नोड अपने घोषित प्रकार और हर गुण के विरुद्ध, और हर संबंध उन चीज़ों के प्रकारों के विरुद्ध जिनकी मेटामॉडल उसके हर छोर पर अनुमति देता है।

ट्रांज़ैक्शनल

नोड का हर बैच एक ही ट्रांज़ैक्शन में लिखा जाता है।

दर्ज

बनाए या बदले गए हर नोड को एक इतिहास प्रविष्टि मिलती है।

दोनों छोर

हर संबंध उसके दोनों छोरों के नोड पर संग्रहीत होता है: कुल 84 लाख प्रविष्टियाँ।

दोबारा पढ़ने में वही टेस्ट फिर से भेजा जाता है: लगभग 98% ठीक वैसा ही जैसा संग्रहीत है, लगभग 1% नाम बदला हुआ, लगभग 1% नया।

रन, चरण दर चरण

समय कहाँ जाता है — और कहाँ नहीं।

चरण हर फ़ाइल के लिए इसी क्रम में चलते हैं और एक-दूसरे पर ओवरलैप नहीं करते, इसलिए उनका योग कुल समय के बराबर होता है। पहले लोड का समय लिखने में जाता है। दोबारा पढ़ने का समय संग्रहीत डेटा पढ़ने में जाता है, बस यह पता लगाने के लिए कि वह नहीं बदला। व्याकरण के विरुद्ध जाँच कभी महँगा हिस्सा नहीं होती।

#

चरण

पहला लोड, सेकंड

दोबारा पढ़ना, सेकंड

1

फ़ाइलें पढ़ना

136
64

2

क्रिएशन मॉडल में बदलना

11
11

3

नए और मौजूदा को अलग करना, संग्रहीत डेटा पढ़ना

266
725

4

रिकॉर्ड बनाना, क्या बदला यह निकालना

105
196

5

मेटामॉडल के विरुद्ध जाँचना

47
2

6

क्रिएशन पूरे करना

19
—

7

बनाए गए नोड लिखना

269
3

8

बदले गए नोड लिखना

—
9

9

संबंध लिखना

491
—

10

इतिहास लिखना

72
7

+

खोज को अद्यतन करना

—
675

कुल, सेकंड में

1 416

1 692

एक रन, अक्टूबर 2026 में मापा गया, उसी बेस कॉन्फ़िगरेशन पर जिस पर हमारी सेवा चलती है — बेंचमार्क के लिए तय आकार की मशीन पर नहीं। स्टोर के बढ़ने के साथ प्रति नोड लागत बढ़ती है: इस टेस्ट के एक-चौथाई पर पहले लोड में प्रति दस लाख नोड 7.5 मिनट लगे; यहाँ 11.2। हम दोनों प्रकाशित करते हैं।

अब आपकी बारी

अपने लोड का समय मापिए। फिर देखिए कि कोई एजेंट हमारे लोड के साथ क्या करता है।

एक पूरी तरह मॉडल किया गया संगठन, आपके कार्य खाते से एक क्लिक। न कोई फ़ॉर्म, न कोई कॉल।