दिलचस्प पोस्ट
जब तक टेक्स्टबॉक्स फोकस खो देता है, तब तक jQuery के टेक्स्टबॉक्स परिवर्तन ईवेंट में आग लगती है? इकाई या जटिल प्रकार '' को एक LINQ से इकाई की क्वेरी में नहीं बनाया जा सकता JQGrid में, क्या स्तंभ फ़ॉर्मेटर के अलावा समूहीकृत कक्ष को समूहीकृत करने के लिए भिन्न फॉर्मेटर का उपयोग करना संभव है? चल रहे जावा प्रक्रिया में Intellij-IDEA डीबगर अटैच करें "HttpContext.Current.Session" बनाम ग्लोबल.एक्सैक्स "this.Session" फ़ाइल एक्सटेंशन का उपयोग करके C # का उपयोग करें यहां दस्तावेज़ 'फ़ाइल का अनपेक्षित अंत' त्रुटि देता है असफल मान्यकरण या अमान्य डुप्लिकेट के लिए खाली HTTP स्थिति कोड जावा में विशेष वर्णों से बचने के लिए यूआरएल कैसे एन्कोड करें Android में एक JSON ऑब्जेक्ट को पार्स कैसे करें मुझे कैसे मिलता है – काम करने के लिए? कोणीय फ़िल्टर ऑब्जेक्ट कुंजी पर बिल्कुल सी # में डिफ़ॉल्ट एक्सेस मॉडिफ़र्स क्या हैं? जावा एफएक्स आवेदन से मैं डिफ़ॉल्ट सिस्टम ब्राउज़र कैसे खोल सकता हूं? गिटहब पुल अनुरोध के लिए स्क्वैश मेरी सभी कमाई एक में

स्ट्रिंग की तुलना करते समय केस संवेदनशील होने के लिए Sqlite3 कैसे सेट करें?

मैं स्ट्रिंग मिलान द्वारा sqlite3 डेटाबेस से रिकॉर्ड का चयन करना चाहता हूं लेकिन अगर मैं '=' ​​का उपयोग किस खंड में किया है, तो मुझे पता चला है कि SQLite3 मामले संवेदनशील है। क्या कोई मुझे बता सकता है कि स्ट्रिंग तुलना करने वाली केस-असंवेदनशील का उपयोग कैसे करें?

Solutions Collecting From Web of "स्ट्रिंग की तुलना करते समय केस संवेदनशील होने के लिए Sqlite3 कैसे सेट करें?"

आप अपनी SELECT क्वेरी में COLLATE NOCASE उपयोग कर सकते हैं:

 SELECT * FROM ... WHERE name = 'someone' COLLATE NOCASE 

Additionaly, SQLite में, आप इंगित कर सकते हैं कि कॉलम में collate nocase निर्दिष्ट करके तालिका बनाते समय एक कॉलम असंवेदनशील होना चाहिए (अन्य विकल्प binary (डिफ़ॉल्ट) और rtrim , देखें)। जब आप एक इंडेक्स भी बनाते हैं तो आप collate nocase निर्दिष्ट कर सकते हैं। उदाहरण के लिए:

 तालिका टेस्ट बनाएं
 (
   Text_Value टेक्स्ट कोलेट nocase
 );

 टेस्ट मूल्यों में डालें ('ए');
 टेस्ट वैल्यू में डालें ('बी');
 टेस्ट वैल्यू में डालें ('सी');

 सूचकांक बनायें Test_Text_Value_Index
   टेस्ट पर (टेक्स्ट_वैल्यू कोलेटेट एनोकेश);

अभिव्यक्तियां जिसमें Test.Text_Value शामिल है। Test.Text_Value अब असंवेदनशील होना चाहिए। उदाहरण के लिए:

 sqlite> टेस्ट से टेक्स्ट का चयन करें जहां टेक्स्ट_वैल्यू = 'बी';
 TEXT_VALUE      
 ----------------
 ख               

 sqlite> Text_Value द्वारा टेस्ट ऑर्डर से Text_Value का चयन करें;
 TEXT_VALUE      
 ----------------
 ए               
 ख               
 सी    

 sqlite> Text_Value desc द्वारा टेस्ट ऑर्डर से Text_Value का चयन करें;
 TEXT_VALUE      
 ----------------
 सी               
 ख               
 ए               

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

 sqlite> टेस्ट_वैल्यू को टेस्ट से समझें जहां टेक्स्ट_वैल्यू = 'बी';
 ऐडर एपोडोड पी 1 पी 2 पी 3                               
 ---------------- -------------- ---------- ---------- ---------------------------------
 0 गोटो 0 16                                           
 1 पूर्णांक 0 0                                            
 2 ओपनरेड 1 3 कुंजीइन्फो (1, एनओसीएएसई)                
 3 सेटनम कॉलम 1 2                                            
 4 स्ट्रिंग 8 0 बी 0 बी                                
 5 इस्नोल -1 14                                           
 6 मेकर्कॉर्ड 1 0 ए                                
 7 मेमस्टोर 0 0                                            
 8 हटोगई 1 14                                           
 9 मेमोलोड 0 0                                            
 10 आईडीएजीजी 1 14 +                                
 11 कॉलम 1 0                                            
 12 कॉलबैक 1 0                                            
 13 अगला 9 9                                            
 14 बंद 1 0                                            
 15 हॉल्ट 0 0                                            
 16 लेनदेन 0 0                                            
 17 VerifyCookie 0 4                                            
 18 गोटो 0 1                                            
 19 नूप 0 0                                            
 SELECT * FROM ... WHERE name = 'someone' COLLATE NOCASE 

आप इसे ऐसा कर सकते हैं:

 SELECT * FROM ... WHERE name LIKE 'someone' 

(यह समाधान नहीं है , लेकिन कुछ मामलों में बहुत सुविधाजनक है)

"समान ऑपरेटर एक तुलनात्मक मिलान करता है। दाईं ओर के परिपथ में पैटर्न होता है, बाएं हाथ के संचालन में पैटर्न के विरुद्ध मिलान करने के लिए स्ट्रिंग होती है। पैटर्न में एक प्रतिशत प्रतीक ("% "), शून्य या अधिक के किसी भी क्रम से मेल खाता है स्ट्रिंग में वर्णों की एक स्ट्रिंग में कोई अंडर्सकोरे ("_") स्ट्रिंग में किसी एक कैरेक्टर से मेल खाता हैकोई भी अन्य वर्ण स्वयं से मेल खाता है या यह कम / ऊपरी केस समकक्ष (यानी केस-असंवेदनशील मिलान) है । (एक बग: SQLite केवल समझता है एएससीआईआई वर्णों के लिए ऊपरी / निचला मामला.ऐसाईआई श्रेणी से परे यूनिकोड वर्णों के लिए पसंद ऑपरेटर केस संवेदी है। उदाहरण के लिए, अभिव्यक्ति 'ए' की तरह 'ए' सच है लेकिन 'ए' 'पसंद' Æ 'गलत है।) । "

यह sqlite के लिए विशिष्ट नहीं है, लेकिन आप ऐसा कर सकते हैं

 SELECT * FROM ... WHERE UPPER(name) = UPPER('someone') 

यहां आपके लिए एक संभावित समाधान है

http://www.codeproject.com/KB/database/SQLiteUTF8CIComparison.aspx

एक अन्य विकल्प का अपना स्वयं का कस्टम बनाना है आप कॉलम पर उस कॉलेशन को सेट कर सकते हैं या इसे अपने चुनिंदा क्लॉज में जोड़ सकते हैं। इसका इस्तेमाल क्रम और तुलना के लिए किया जाएगा।

इसे 'वीओआईएलए' जैसे 'वॉयला' बनाने के लिए इस्तेमाल किया जा सकता है

http://www.sqlite.org/capi3ref.html#sqlite3_create_collation

कोटिंग फंक्शन को एक पूर्णांक लौटा देना चाहिए जो नकारात्मक, शून्य या सकारात्मक है अगर पहली स्ट्रिंग क्रमशः दूसरे से कम, बराबर या दूसरे से अधिक है।

एक और विकल्प जो आपके मामले में या नहीं समझ सकता है, वास्तव में आपके मौजूदा कॉलम के पूर्व-निम्न मूल्य वाले मूल्यों के साथ अलग कॉलम होना चाहिए। इसे SQLite फ़ंक्शन LOWER() का उपयोग करके आबाद किया जा सकता है, और फिर आप इसके बजाय इस कॉलम पर मिलान कर सकते हैं।

जाहिर है, यह अतिरेक और असंगतता के लिए एक संभावित है, लेकिन यदि आपका डेटा स्थिर है तो यह एक उपयुक्त विकल्प हो सकता है

यदि कॉलम टाइप char तो आपको रिक्त स्थान के साथ पूछे जाने वाले मूल्य को जोड़ना होगा, कृपया इस प्रश्न का संदर्भ यहां देखें। यह COLLATE NOCASE या अन्य समाधानों (ऊपरी (), आदि) में से एक के अलावा।

आप टेबल वालेंस के साथ संबंधित स्ट्रिंग की तुलना करने के लिए समान क्वेरी का उपयोग कर सकते हैं।

तालिका के नाम से कॉलम का नाम चुनें जहां स्तंभ नाम 'संबंधित तुलनात्मक मान';

यह मेरे लिए बिल्कुल काम कर रहा है SELECT NAME FROM TABLE_NAME WHERE NAME = 'test Name' COLLATE NOCASE