एसक्यूएल जैसे अभिव्यक्ति को फ्लाई पर रेगेक्स में बदलने के लिए मैं किस कोड का उपयोग करूंगा?

Question

मैं बराबर regex अर्थात

LIKE '%this%' 
LIKE 'Sm_th' 
LIKE '[C-P]arsen' 

ऐसा करने के लिए सबसे अच्छा तरीका क्या है करने के लिए मक्खी पर बयान की तरह एक एसक्यूएल कन्वर्ट करने के लिए देख रहा हूँ?

पीएस मैं इसे नेट फ्रेमवर्क (सी #) पर करने के लिए देख रहा हूँ।

Answer 1

निम्नलिखित Regex एक MatchEvaluator प्रतिनिधि की मदद से एक Regex पैटर्न में पैटर्न की तरह एक एसक्यूएल बदल देता है। यह स्क्वायर ब्रैकेट ब्लॉक को सही तरीके से संभालता है और विशेष रेगेक्स वर्णों से बचता है।

string regexPattern = Regex.Replace(
    likePattern, 
    @"[%_]|\[[^]]*\]|[^%_[]+", 
    match => 
    { 
     if (match.Value == "%") 
     { 
      return ".*"; 
     } 
     if (match.Value == "_") 
     { 
      return "."; 
     } 
     if (match.Value.StartsWith("[") && match.Value.EndsWith("]")) 
     { 
      return match.Value; 
     } 
     return Regex.Escape(match.Value); 
    }); 

Answer 2

मुझे Regexp::Wildcards नामक एक पर्ल मॉड्यूल मिला। आप इसे पोर्ट करने या Perl.NET को आजमाने का प्रयास कर सकते हैं। मुझे एहसास है कि आप खुद को कुछ भी लिख सकते हैं।

Answer 3

ऊपर अपने उदाहरण से, मैं इसे इस तरह आक्रमण करेंगे (मैं सामान्य शब्दों में बात है क्योंकि मैं सी # पता नहीं है):

तोड़ यह अलग की तरह '...' द्वारा, डाल दिया। .. एक सरणी में टुकड़े। द्वारा संकेत बदलें नहीं छोड़ा जाएगा %। *, द्वारा रेखांकित।, और इस मामले में [सी पी] आर्सेन regex में सीधे अनुवाद करता है।

एक पाइप के साथ सरणी टुकड़ों को एक साथ वापस शामिल करें, और परिणाम कोष्ठक, और मानक regex बिट्स में लपेटें।

परिणाम होगा:

/^(.*this.*|Sm.th|[C-P]arsen)$/ 

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

% becomes .* 
_ becomes . 

Answer 4

@ नाथन-Baulch के समाधान आप भी इस मामले में जहां एक कस्टम एस्केप वर्ण LIKE '!%' ESCAPE '!' सिंटैक्स का उपयोग परिभाषित किया गया है संभाल करने के लिए नीचे दिए गए कोड का उपयोग कर सकते करने के अलावा

।

public Regex ConvertSqlLikeToDotNetRegex(string regex, char? likeEscape = null) 
    { 
     var pattern = string.Format(@" 
      {0}[%_]| 
      [%_]| 
      \[[^]]*\]| 
      [^%_[{0}]+ 
      ", likeEscape); 

     var regexPattern = Regex.Replace(
      regex, 
      pattern, 
      ConvertWildcardsAndEscapedCharacters, 
      RegexOptions.IgnorePatternWhitespace); 

     regexPattern = "^" + regexPattern + "$"; 

     return new Regex(regexPattern, 
      !m_CaseSensitive ? RegexOptions.IgnoreCase : RegexOptions.None); 
    } 

    private string ConvertWildcardsAndEscapedCharacters(Match match) 
    { 
     // Wildcards 
     switch (match.Value) 
     { 
      case "%": 
       return ".*"; 
      case "_": 
       return "."; 
     } 

     // Remove SQL defined escape characters from C# regex 
     if (StartsWithEscapeCharacter(match.Value, likeEscape)) 
     { 
      return match.Value.Remove(0, 1); 
     } 

     // Pass anything contained in []s straight through 
     // (These have the same behaviour in SQL LIKE Regex and C# Regex) 
     if (StartsAndEndsWithSquareBrackets(match.Value)) 
     { 
      return match.Value; 
     } 

     return Regex.Escape(match.Value); 
    } 

    private static bool StartsAndEndsWithSquareBrackets(string text) 
    { 
     return text.StartsWith("[", StringComparison.Ordinal) && 
       text.EndsWith("]", StringComparison.Ordinal); 
    } 

    private bool StartsWithEscapeCharacter(string text, char? likeEscape) 
    { 
     return (likeEscape != null) && 
       text.StartsWith(likeEscape.ToString(), StringComparison.Ordinal); 
    }