निरंतर नियम मिलान के लिए पैटर्न

Question

मेरे पास संदेशों की निरंतर स्ट्रीम है जिसका विश्लेषण किया जाता है। विश्लेषण विभिन्न चर, जैसे लेखक, विषय, भावना, शब्द गणना और विशिष्ट शब्दों का एक सेट देता है। सिस्टम में उपयोगकर्ता नियमों को परिभाषित करने में सक्षम हैं, जो मेल खाने पर एक चेतावनी ट्रिगर करना चाहिए। नियम एक एसक्यूएल-डेटाबेस में संग्रहीत किया जाना चाहिए। एक नियम संदेश विश्लेषण से एकल मानदंड का संयोजन है, यानी word-count > 15 && topic = 'StackOverflow' && sentiment > 2.0 && word-set contains 'great'। संदेश विश्लेषण के अंत में प्रत्येक अनुमत नियम-मानदंड प्रदान किया जाता है, जिसके बाद नियम सत्यापन ट्रिगर किया जाएगा और जिसे जावा में लागू किया गया है।

सिस्टम में सभी उपयोगकर्ताओं द्वारा परिभाषित सभी नियमों के लिए प्रत्येक संदेश की जांच की जानी चाहिए, जिसमें बहुत अधिक गणना शक्ति होती है (वर्तमान में 10+ संदेश/सेकंड हैं और जांच के लिए 10.000+ नियम होंगे)। मिलान प्रक्रिया को तेज़ करने के लिए कोई आम पैटर्न है, हो सकता है कि नियमों को समानांतर में चेक किया जा सके, एक-एक करके छोड़कर? क्या यह शुद्ध एसक्यूएल में ऐसा करना संभव है, विभिन्न प्रकार के नियमों के लिए एक स्कीमा कैसा दिखता है?

Answer 1

आपकी विचार मिलान के केवल थ्रूपुट से अधिक होने की संभावना है। उदाहरण के लिए, आपको नियमों को बनाए रखने की आवश्यकता है।

लेकिन, आइए नियमों और संदेशों का एक स्थिर सेट मान लें जिसमें सभी नियमों को पूरा करने के लिए आवश्यक सभी फ़ील्ड शामिल हैं। एसक्यूएल का उपयोग करके, संरचना message तालिका से शुरू होगी। इस तालिका में insert ट्रिगर होगा। नियमों से मेल खाने के लिए सम्मिलित ट्रिगर जिम्मेदार होगा। इसे करने का बेहतरीन तरीका क्या है?

प्रति सेकंड 10+ संदेशों के साथ, आपकी प्रसंस्करण स्वाभाविक रूप से समानांतर होगी, भले ही प्रत्येक मैच एकल थ्रेड हो। मुझे यकीन नहीं है कि मैच को समानांतर करने के लिए आपको कितना प्रयास करना होगा। डेटाबेस में समांतरता आम तौर पर उनके बीच एसक्यूएल स्टेटमेंट के भीतर आता है।

सभी प्रकार के समाधान हैं। उदाहरण के लिए, आप नियमों को विशाल संग्रहित प्रक्रिया में कोड के रूप में एन्कोड कर सकते हैं। यह बनाए रखने के लिए एक दुःस्वप्न होगा, संग्रहित प्रक्रियाओं की लंबाई सीमा से अधिक हो सकता है, और दर्दनाक धीमा हो सकता है।

एक और पागल विचार। किसी नियम में किसी नियम के लिए मेल खाने वाले संदेशों को उस नियम के लिए संग्रहीत करें, और एक बाधा केवल मिलान करने वाले लोगों को लोड करें। आपकी प्रक्रिया तब एक अरब प्रविष्टि बयान की तरह दिखती है।

अधिक गंभीरता से, आप आगे कोड के साथ इस तरह के रूप जाना होगा:

select * 
from rules 
where . . . 

परिणाम सेट मिलान नियम होगा। where खंड हो सकता है कुछ की तरह:

select * 
from rules r 
where @wordcount > coalesce(r.wordcount, 0) and 
     @topic = coalesce(r.topic, @topic) and 
     . . . 

है यही कारण है, सभी नियमों के लिए हर संभव तुलना where खंड में होगा। और, नियमों को पूर्व-संसाधित किया जाएगा कि उन्हें किस खंड की आवश्यकता है।

तुम भी बाहरी चर के साथ बांटना सकते हैं, और सीधे क्वेरी का उपयोग:

select * 
from rules r cross join inserted i 
where i.wordcount > coalesce(r.wordcount, 0) and 
     i.topic = coalesce(r.topic, @topic) and 
     . . . 

तो, हाँ, यह एसक्यूएल में संभव है। और, आप समानांतर में मिलान कर सकते हैं। डेटाबेस तुलनाओं के लिए उपयुक्त प्रारूप में अपने नियम प्राप्त करने के लिए आपको बस काम करना होगा।

Answer 2

मैंने सी # में एक समान समस्या हल की है हालांकि SQL का उपयोग नहीं किया जा रहा है।

मैंने पोर्टेबिलिटी के प्रयोजनों के लिए डेटाबेस में क्रमबद्ध एक्सएमएल के रूप में नियमों को संग्रहीत किया।

एप्लिकेशन स्टार्टअप पर, या जब नियम तालिका बदल गई (नियम कैश को फ़्लश करने के लिए मजबूर किया गया) मैंने डेटाबेस से सभी नियमों को लोड किया और उन्हें उचित वर्गों में deserialized।

तब प्रत्येक ऐप सर्वर पर डेटा आया क्योंकि मैंने आने वाले डेटा के खिलाफ नियमों को निष्पादित किया और नियमों को पारित करने के लिए उपयुक्त कार्रवाई निष्पादित की। (उस समय मैं ऐप सर्वर पर प्रो में कार्रवाई कर रहा था, लेकिन अब मैं इसे कतार में डंप कर दूंगा।)

इसका आपके ऐप क्लस्टर में गणना को फैलाने का लाभ है और इसे सभी नहीं रख रहा है डेटाबेस मशीन पर चक्र चूसने।