performance - Find match over Array of RegEx in MongoDB Collection -
मेरे पास इन क्षेत्रों के साथ एक संग्रह है:
{"category": "ONE "," डेटा ": {{" regex ":" / ^ [0-9] {2} $ / "," प्रकार ":" TYPE1 "}, {" regex ":" / ^ [az] {3} $ / "," Type ":" TYPE2 "} // आदि]}
तो मेरा इनपुट" abc "है इसलिए मैं इसी प्रकार (या सर्वोत्तम मिलान प्राप्त करना चाहता हूं, हालांकि शुरू में मैं मान रहा हूँ RegExes अनन्य हैं)। क्या सभ्य प्रदर्शन के साथ इसे हासिल करने का कोई संभव तरीका है? (जो RegEx सरणी के प्रत्येक आइटम पर पुनरावृत्त नहीं करेगा)
कृपया ध्यान दें कि यदि संभव हो तो स्कीमा को फिर से व्यवस्थित किया जा सकता है, क्योंकि यह परियोजना अभी भी डिजाइन चरण में है। तो विकल्प का स्वागत किया जाएगा।
प्रत्येक श्रेणी में लगभग 100 - 150 रेगएक्स हो सकते हैं। मैं लगभग 300 श्रेणियों की योजना है लेकिन मुझे पता है कि प्रकार परस्पर अनन्य हैं
एक श्रेणी के लिए वास्तविक दुनिया का उदाहरण:
type1 = ^ 34 [0-9] {4} $, प्रकार 2 = ^ 54 [0-9] {4} $, प्रकार 3 = ^ 39 [0- 9] {4} $, प्रकार 4 = ^ 1 [5- 9] {2} $, प्रकार 5 = ^ 2 [4- 9] {2,3} $
< RegEx ( Divide et Impera ) का वर्णन करने के लिए संख्या को सीमित करने में बहुत मदद मिलेगी / pre>
संसाधित करने के लिए आवश्यक दस्तावेजों की।
[: अल्फा:]
, [: अंक:]
, [: alnum:]
, आदि) इनमें से प्रत्येक को कार्यान्वित करने के लिए जटिलता (कोड और / या मैन्युअल इनपुट) में जोड़ना होगा क्वेरी से पहले searchterm
का वर्णन करने के लिए सम्मिलन और कुछ ओवरहेड भी।
एक श्रेणी में परस्पर विशेष प्रकार के होने से चीजें सरल होती हैं, लेकिन श्रेणियों के बीच क्या है?
100-150 RegExps / category => 30k से 45k RegExps
... कुछ निश्चित रूप से हो जाएगा सटीक डुप्लिकेट यदि उनमें से अधिकतर नहीं हैं।
इस दृष्टिकोण में मैं उलट स्टाइल बनाम आपकी प्रारंभिक प्रस्तावित स्कीमा।
नोट: इस डेमो में सीमित करने के लिए केवल स्ट्रिंग लम्बाई शामिल है, यह मैन्युअल इनपुट के लिए स्वाभाविक रूप से आ सकती है क्योंकि यह RegEx <
{"max_length": NumberLong (2) के रूप में regexes
संग्रह rewiting पर विचार करें: / em> "" ["एक / टाइप 1", "नौ / टाइप 6"]}, {"अधिकतम_ लैंघ"}, "लम्बाई" : नंबर "लांग" (4), "मिनि_ लैंन्थ": नंबर लाँग (3), "रेगेक्स": "^ 2 [4- 9] [2,3] $", "प्रकार": ["एक / टाइप 5", "दो / टाइप 2 "," SIX / TYPE8 "]}, {" max_length ": नंबर लाँग (6), "" ["ONE / TYPE3", "SIX / TYPE2"]}, {"अधिकतम_लांबी"]: "न्यूनतम_लांबी": संख्या लांग (6), "रीगेक्स": "^ 39 [0-9] [4] $", "प्रकार" : "[" एक / टाइप 2 "]}
:" संख्या "[3]," मिनि_ लांघ ": नंबर लोंग (3)," रीगेक्स ":" ^ [एज़] [3] $ "," प्रकार " .. यह प्रत्येक स्वयं के दस्तावेज़ के रूप में एक अनूठे RegEx है, जिसमें ये श्रेणियां हैं (प्रति श्रेणी में कई प्रकार के लिए एक्स्टेंसिबल)
डेमो एकत्रीकरण कोड:
फ़ंक्शन () {मैच = नल; क्वेरी = 'एबीसी'; Db.regexes.aggregate ({$ match: {max_length: {$ gte: query.length}, min_length: {$ lte: query.length}, प्रकार: / ^ ONE \ //}}, {$ project: {regex : 1, प्रकार: 1, _id: 0}})। Result.some (फ़ंक्शन (पुनः) {यदि (query.match (नया RegExp (re.regex)) वापसी मैच = re.types;}); वापसी मैच; }
'abc'
क्वेरी के लिए लौटें:
["ONE / TYPE2"]
यह केवल इन दो दस्तावेज़ों के विरुद्ध चलेंगे:
{"regex": "^ 2 [4-9] [2,3] $", "प्रकार": [" एक / टाइप 5 "," TWO / TYPE2 "," SIX / TYPE8 "]}, {" रेगेक्स ":" ^ [एज़] [3] $ "," प्रकार ": [" ONE / TYPE2 "]} लम्बाई 3
से संकुचित और श्रेणी एक
है।
POSIX
डिस्क्रिप्टर ( searchterm
के खिलाफ परीक्षण करने के लिए आसान है, लेकिन डीबी में 2 RegExps इनपुट करना पड़ता है) को कार्यान्वित करके और भी संकुचित किया जा सकता है
Comments
Post a Comment