गुणवत्ता आश्वासन

टेस्टिंग पद्धति

मौजूदा सत्यापन PostgreSQL और SQLite पर समर्थित रीड क्वेरी को कवर करता है, साथ ही Prisma v6, v7, v8, Drizzle और जनरेट किए गए SQL की बेंचमार्क रिपोर्ट भी हैं।

E2E सूट
मौजूदा
क्वेरी पैरिटी सत्यापित
पैरिटी कवरेज
100%
बाइट-दर-बाइट मिलान
डेटाबेस इंजन
2
PostgreSQL और SQLite
ORM बेंचमार्क
4
Prisma v6/v7/v8, Drizzle

हम शुद्धता कैसे सत्यापित करते हैं

हर टेस्ट 5 चरणों वाली कठोर सत्यापन प्रक्रिया का पालन करता है, ताकि जनरेट किया गया SQL Prisma जैसे ही परिणाम दे

  1. Prisma क्वेरी से SQL जनरेट करें

    Prisma क्वेरी आर्गुमेंट पार्स करें और उन्हीं मॉडल और स्कीमा का उपयोग करके समतुल्य SQL जनरेट करें। जनरेट किया गया SQL सुरक्षा और परफ़ॉर्मेंस के लिए पैरामीटराइज़्ड क्वेरी का उपयोग करता है।

  2. दोनों क्वेरी समानांतर में निष्पादित करें

    जनरेट किए गए SQL को postgres.js या better-sqlite3 के ज़रिए सीधे चलाएँ, और वही क्वेरी Prisma के ज़रिए निष्पादित करें। दोनों एक ही डेटाबेस स्थिति पर चलती हैं।

  3. परिणाम नॉर्मलाइज़ करें

    टाइप के अंतर (BigInt बनाम Number, Decimal प्रिसिज़न, Date सीरियलाइज़ेशन) संभालें और निष्पक्ष तुलना के लिए ऑब्जेक्ट कुंजियों का क्रम नॉर्मलाइज़ करें।

  4. गहन समानता जाँच

    पुष्टि करें कि परिणाम बिल्कुल मेल खाते हैं: पंक्तियों की समान संख्या, समान फ़ील्ड मान, समान नेस्टेड रिलेशन, समान क्रम। कोई भी असमानता टेस्ट को विफल कर देती है।

  5. परफ़ॉर्मेंस बेंचमार्क

    5 वार्मअप रन के साथ निष्पादन समय मापें, फिर प्रति टेस्ट 10-50 पुनरावृत्तियों का औसत लें। Prisma v6, Prisma v7, Prisma v8 और Drizzle ORM से तुलना करें।

उन्नत सत्यापन तकनीकें

डेटा टाइप नॉर्मलाइज़ेशन

BigInt रूपांतरण
तुलना के लिए JavaScript BigInt → Number
Decimal प्रबंधन
Prisma Decimal → 10 अंकों की प्रिसिज़न वाला Float
Date नॉर्मलाइज़ेशन
सभी DateTime मान → null (टाइमस्टैम्प नहीं, डेटा पर ध्यान)
JSON पार्सिंग
JSON स्ट्रिंग की स्वचालित पहचान और पार्सिंग
ऑब्जेक्ट कुंजी सॉर्टिंग
सुसंगत तुलना के लिए वर्णानुक्रम

परफ़ॉर्मेंस बेंचमार्किंग

वार्मअप चरण
कैश और JIT को तैयार करने के लिए 5 पुनरावृत्तियाँ
अनुकूली पुनरावृत्तियाँ
क्वेरी की जटिलता के आधार पर 5-50 रन
पृथक मापन
हर क्वेरी प्रकार को स्वतंत्र रूप से मापा जाता है
मल्टी-ORM तुलना
Prisma v6, v7, v8, Drizzle, जनरेट किया गया SQL
SQL जनरेशन समय
क्वेरी जनरेशन ओवरहेड के लिए अलग टाइमिंग

व्यापक टेस्ट कवरेज

टेस्ट कई जटिलता स्तरों पर हर Prisma रीड ऑपरेशन को कवर करते हैं

क्वेरी ऑपरेशन

  • जटिल फ़िल्टर के साथ findMany
  • skip और पेजिनेशन के साथ findFirst
  • ID और unique फ़ील्ड द्वारा findUnique
  • WHERE शर्तों के साथ count
  • aggregate (sum, avg, min, max)
  • HAVING क्लॉज़ के साथ groupBy

जटिल परिदृश्य

  • नेस्टेड include (4 स्तर गहरे)
  • रिलेशन फ़िल्टर (some/every/none)
  • विंडो फ़ंक्शन के साथ Distinct
  • कर्सर पेजिनेशन
  • select + include एक साथ
  • रिलेशन काउंट (_count)

फ़िल्टर प्रकार

  • तुलना (lt/lte/gt/gte)
  • लॉजिकल (AND/OR/NOT)
  • स्ट्रिंग ऑपरेशन (contains/startsWith)
  • NULL जाँच (is/isNot)
  • IN/NOT IN ऐरे
  • केस सेंसिटिविटी मोड

PostgreSQL टेस्टिंग

  • ILIKE केस-इनसेंसिटिव खोज
  • JSON/JSONB ऑपरेशन
  • ऐरे फ़ील्ड प्रबंधन
  • कंपोज़िट टाइप समर्थन
  • विंडो फ़ंक्शन सत्यापन
  • ट्रांज़ैक्शन आइसोलेशन टेस्टिंग

SQLite टेस्टिंग

  • LIKE पैटर्न मिलान
  • JSON1 एक्सटेंशन सत्यापन
  • विंडो फ़ंक्शन एमुलेशन
  • DISTINCT ऑप्टिमाइज़ेशन
  • सबक्वेरी कोरिलेशन
  • टेक्स्ट एफ़िनिटी प्रबंधन

उदाहरण टेस्ट केस

देखें कि हम रिलेशन फ़िल्टर वाली जटिल नेस्टेड क्वेरी को कैसे सत्यापित करते हैं

tests/e2e/postgres.test.ts
it('nested relation filter', () =>
  runParityTest(
    db,
    benchmarkResults,
    'findMany nested relation',
    'Organization',
    {
      method: 'findMany',
      where: {
        projects: {
          some: {
            tasks: { some: { status: 'DONE' } }
          }
        }
      }
    },
    () => db.prisma.organization.findMany({
      where: {
        projects: {
          some: {
            tasks: { some: { status: 'DONE' } }
          }
        }
      },
      orderBy: { id: 'asc' }
    }),
  )
)

// runParityTest आंतरिक रूप से:
// 1. आर्गुमेंट के साथ generateSQL() को कॉल करता है
// 2. जनरेट किए गए SQL को सीधे निष्पादित करता है
// 3. Prisma क्वेरी निष्पादित करता है
// 4. दोनों परिणामों को नॉर्मलाइज़ करता है
// 5. गहन समानता जाँच - कोई भी अंतर होने पर विफल
// 6. निष्पादन समय का बेंचमार्क करता है

टेस्ट निष्पादन के दौरान क्या होता है

  1. 1क्वेरी जनरेशन (माइक्रोसेकंड)

    generateSQL() फ़ंक्शन Prisma आर्गुमेंट पार्स करता है और पैरामीटराइज़्ड SQL बनाता है। क्वेरी जनरेशन ओवरहेड मापने के लिए इस चरण का अलग से बेंचमार्क किया जाता है।

  2. 2समानांतर निष्पादन (मिलीसेकंड)

    Promise.all() का उपयोग करके दोनों क्वेरी एक साथ एक ही डेटाबेस स्थिति पर चलती हैं, जिससे निष्पक्ष तुलना और समान डेटा परिस्थितियाँ सुनिश्चित होती हैं।

  3. 3गहन नॉर्मलाइज़ेशन

    परिणाम रिकर्सिव नॉर्मलाइज़ेशन से गुज़रते हैं: BigInt→Number, Decimal→Float(10), Date→null, JSON parse, कुंजी सॉर्टिंग। इससे बाइट-दर-बाइट तुलना की सटीकता सुनिश्चित होती है।

  4. 4सख़्त समानता

    शून्य सहनशीलता के साथ JSON stringify तुलना। पंक्तियों की संख्या, फ़ील्ड मान, नेस्टेड ऑब्जेक्ट या क्रम में कोई भी असमानता टेस्ट को विस्तृत diff आउटपुट के साथ विफल कर देती है।

  5. 5परफ़ॉर्मेंस मापन

    सत्यापन के बाद, 5-50 पुनरावृत्तियाँ औसत निष्पादन समय मापती हैं। परिणामों में शामिल हैं: Prisma v6, Prisma v7, Prisma v8, Drizzle ORM, जनरेट किया गया SQL और SQL जनरेशन ओवरहेड।

मल्टी-वर्ज़न सत्यापन

हर बेंचमार्क किया गया टेस्ट, जहाँ समर्थित हो, Prisma v6, v7 और v8 पर चलता है:

Prisma v6 (6.19.3)

  • PrismaClient का सीधा उपयोग
  • पुराना (legacy) इंजन आर्किटेक्चर
  • बेसलाइन परफ़ॉर्मेंस मेट्रिक्स

Prisma v7 (7.10.0)

  • एडैप्टर-आधारित आर्किटेक्चर
  • @prisma/adapter-pg और adapter-better-sqlite3
  • नए इंजन ऑप्टिमाइज़ेशन

Prisma v8 (8.1.0-dev.1)

  • Prisma v8 dev रिलीज़ का कवरेज
  • एडैप्टर-आधारित आर्किटेक्चर
  • PostgreSQL और SQLite बेंचमार्क पैरिटी

स्वचालित बेंचमार्क रिपोर्ट

पूर्ण पारदर्शिता के लिए सभी बेंचमार्क परिणाम स्वचालित रूप से जनरेट होते हैं और JSON फ़ाइलों के रूप में संग्रहीत किए जाते हैं:

हर फ़ाइल में शामिल है: टेस्ट का नाम, Prisma निष्पादन समय, जनरेट किए गए SQL का समय, Drizzle समय, गति वृद्धि अनुपात और ISO टाइमस्टैम्प।

पूरा टेस्ट सूट देखें

सत्यापन सूट और बेंचमार्क रिपोर्ट ओपन सोर्स हैं। टेस्ट कोड, बेंचमार्क डेटा और पैरिटी जाँच की समीक्षा करें।