एंटिटी फ्रेमवर्क में कंपाउंड कुंजी WHERE क्लॉज

हाल ही में, जब संस्करण के साथ एक परियोजना विकसित की गई, तो मैं समग्र कुंजियों की सूची से आइटम का चयन करने की समस्या में भाग गया।

समस्या का विवरण:

जब संस्करण की "स्थितियों में" विकसित हो रहा है, प्राथमिक कुंजी तालिकाओं में आईडी और संशोधन शामिल हैं। समग्र कुंजी (आईडी, संशोधन) की प्रेषित सूची से डेटाबेस तालिका से चयन प्राप्त करना आवश्यक है। ऐसी SQL क्वेरी इस तरह दिखेगी (एक सूची में पाँच वस्तुओं के लिए):

/*  1 */ select * from dbo.[Items] i where (i.Id = 1 and i.Revision = 2) OR (i.Id = 1 and i.Revision = 4) OR (i.Id = 3 and i.Revision = 3) OR (i.Id = 3 and i.Revision = 4) OR (i.Id = 5 and i.Revision = 9) 

लेकिन एंटिटी फ्रेमवर्क आपको समग्र कुंजियों की सूची के लिए ऐसी क्वेरी लिखने की अनुमति नहीं देता है। मानक तरीकों से अधिकतम किया जा सकता है:

 context.Items.Where(i=> idList.Contains(i.Id) && revisionList.Contains(i.Revision)) 

क्या इस तरह के एक अनुरोध (अवधारणा) में बदल जाएगा:

 /*  2 */ select * from dbo.[Items] i where i.Id in (1, 3, 5) and i.Revision in (2, 3, 4, 9) 

यदि आइटम तालिका में निम्न पहचानकर्ता वाले तत्व हैं, तो यह क्वेरी गलत परिणाम देगी:
Id = 3, संशोधन = 2
Id = 3, संशोधन = 4
और समग्र कुंजियों की सूची में ऐसी रेखाएँ हैं:
Id = 5, संशोधन = 4
Id = 3, संशोधन = 2

तो क्या करें?

इंटरनेट पर, ORM के लिए, निम्न विधि सामान्य है:
डेटाबेस और सूची में आईडी और संशोधन को संयोजित करना और परिणामी मूल्य द्वारा तुलना करना आवश्यक है। संगति से तात्पर्य है तार का संघात, या, यदि Id और संशोधन प्रकार int के हैं, तो ऑफसेट और प्रकार के लंबे (bigint) मिलते हैं।
संघटन के मामले के लिए:

 /*  3 */ select * from dbo.[Items] i where CONVERT(nvarchar(10), i.Id)+ ',' + CONVERT(nvarchar(10), i.Revision) in ('1,2', '1,4', '3,3', '3,4', '5,9') 

यदि हम "अनुरोध 1" और "अनुरोध 3" की तुलना करते हैं, तो उत्तरार्द्ध को निष्पादित करने के लिए, हमें एक अतिरिक्त स्तंभ (इसके अलावा, इसके निर्माण के लिए, हमें 2 प्रकार के रूपांतरण संचालन और 2 संगति संचालन करने की आवश्यकता है)। और "अनुरोध 1" में केवल तुलना संचालन का उपयोग किया जाता है। इसके आधार पर, मैं मानता हूं कि "अनुरोध 1" सस्ता है।
लेकिन MSSQL 2008 R2 दोनों प्रश्नों के लिए एक ही निष्पादन योजना देता है (प्रश्नों को उस रूप में जिसमें वे यहां प्रस्तुत किए गए हैं)।

तो, आपको "अनुरोध 1" के रूप में एक क्वेरी बनाने के लिए एंटिटी फ्रेमवर्क कैसे मिलता है।

इकाई फ्रेमवर्क आपको समग्र कुंजी के विशिष्ट सेट के लिए ऐसा अनुरोध लिखने की अनुमति देता है:

 context.Items.Where(i=> (i.Id == 1 && i.Revision == 2) || (i.Id == 1 && i.Revision == 4) || (i.Id == 3 && i.Revision == 3) || (i.Id == 3 && i.Revision == 4) || (i.Id == 5 && i.Revision == 9)) 

लेकिन सूची के साथ क्या करना है? रचनात्मक रूप से अभिव्यक्ति उत्पन्न करें! .NET आपको ऐसा करने की अनुमति देता है। ऐसा करने के लिए, सभी अवसरों के लिए स्थैतिक विधियों के एक समूह के साथ अभिव्यक्ति वर्ग का उपयोग करें। हम अभिव्यक्ति को इस प्रकार लिख सकते हैं:

 i.Id == list.Id && i.Revision == list.Revision 

फिर इसे आवश्यक संख्या में कॉपी करें, सूची के बजाय स्थिरांक के रूप में सूची से आवश्यक मानों को प्रतिस्थापित करें। सूची और सूची। संशोधन और फिर उन्हें एक ऑपरेशन के माध्यम से एक में इकट्ठा करें, उदाहरण के लिए, ||

यह कैसे करें:
मान लीजिए कि संयुक्त कुंजियों की हमारी सूची सूची है। जहां आइडेंटिफायर ईद, संशोधन की एक जोड़ी के लिए एक आवरण है।
एंटिटी फ्रेमवर्क में, जहां बाइनरी एक्सप्रेशन प्रकार का उपयोग किया जाता है, प्रत्येक बाइनरी एक्सप्रेशन अभिव्यक्ति में 3 मुख्य क्षेत्र होते हैं:

• वाम (प्रकार अभिव्यक्ति) - बाईं ओर
• राइट (प्रकार अभिव्यक्ति) - सही हिस्सा
• NodeType (प्रकार अभिव्यक्ति टाइप) - ऑपरेशन (या, और, आदि)

list.Id और list.Revision भी अभिव्यक्ति हैं, केवल प्रकार के सदस्य। इसकी ReflectedType संपत्ति का उपयोग करके, आप यह जान सकते हैं कि हमारे पास किस प्रकार की सूची है, और यदि यह पहचानकर्ता है, तो हम ConstExExpression के साथ MemberExpression (list.Id) को प्रतिस्थापित कर सकते हैं (किसी विशिष्ट उदाहरण के लिए Id मान प्रतिबिंबन या प्रतिनिधि का उपयोग करके प्राप्त किया जा सकता है)

उसके बाद, हमें उन अभिव्यक्तियों की एक सूची मिलती है जिन्हें एक में एकत्र करने की आवश्यकता होती है।
सबसे आसान विकल्प उन्हें एक समय में एक इकट्ठा करना है:

 BinaryExpression BuildExpression(ExpressionType type, List<BinaryExpression> expressions) { if(expressions.Count == 0) return null; if(expressions.Count == 1) return expressions[0]; var resExpression = expressions[0]; for (int i = 1; i < expressions.Count; i++) resExpression = Expression.MakeBinary(type, resExpression, expressions[i]); return resExpression; } 

लेकिन एक गंभीर समस्या है। दाईं ओर प्रतिस्थापित प्रत्येक अभिव्यक्ति की तुलना बाईं ओर की पूरी अभिव्यक्ति के साथ की जाती है, अर्थात यह इस अभिव्यक्ति को बताता है:

 ((((((i.Id == 1 && i.Revision == 2) || (i.Id == 1 && i.Revision == 4)) || (i.Id == 3 && i.Revision == 3)) || (i.Id == 3 && i.Revision == 4)) || (i.Id == 5 && i.Revision == 9)) 

इस अभिव्यक्ति में, शुरुआत में अतिरिक्त कोष्ठक की संख्या सूची में तत्वों की संख्या के बराबर होगी। और यह सब ठीक होगा, जब एसक्यूएल क्वेरी बनाने के लिए इस अभिव्यक्ति को पार्स करते हैं, तो एंटिटी फ्रेमवर्क अभिव्यक्ति में गहराई तक जाने के लिए पुनरावृत्ति का उपयोग करता है, और सूची में ~ 1000 तत्वों (व्यावहारिक टिप्पणियों) के साथ, एक StackOverflowException उड़ जाता है। वैसे, काफी दिलचस्प LINQ डायनेमिक क्वेरी लाइब्रेरी प्रोजेक्ट जिसे मैंने घर पर उपयोग करने की कोशिश की, लेकिन उपरोक्त समस्या के कारण इनकार कर दिया, उसी समस्या से ग्रस्त है।

लेकिन इस समस्या को हराया जा सकता है! ऐसा करने के लिए, आपको सही पर तत्वों को प्रतिस्थापित किए बिना अभिव्यक्ति का निर्माण करने की आवश्यकता है, और इसे एक द्विआधारी पेड़ की तरह बनाना है:

 private static BinaryExpression BuildExpression(ExpressionType type, List<BinaryExpression> expressions) { if (expressions.Count == 0) return Expression.Equal(Expression.Constant(0), Expression.Constant(1)); //  ,        else if (expressions.Count == 1) return expressions[0]; var center = expressions.Count / 2; return Expression.MakeBinary(type, BuildExpression(type, expressions.Take(center).ToList()), BuildExpression(type, expressions.Skip(center).Take(expressions.Count - center).ToList())); } 

इस तरह से प्राप्त की गई अभिव्यक्ति सूची में 1,000,000 वस्तुओं के साथ भी StackOverflowException नहीं बढ़ाती है (मैं इसे अब और नहीं जांचता, क्योंकि कई मापदंडों के साथ SQL सर्वर पर्याप्त समय के लिए क्वेरी को निष्पादित करने से इनकार करता है)।

इन सभी के आधार पर, मैंने विस्तार विधियाँ बनाईं, जहाँ पर इस विधि को अधिभारित किया और अपनी परियोजनाओं में इसका उपयोग किया।

इन घटनाओं को साझा करने के लिए, मैंने कोडप्लेक्स पर एक प्रोजेक्ट बनाया, जहाँ मैंने EFCompoundkeyWhere के लिए स्रोत कोड अपलोड किया

मुझे उम्मीद है कि यह किसी के लिए उपयोगी है।