दिलचस्प पोस्ट
सीएसएस में सेलपैडिंग और सेलेक्शनिंग सेट करें? डिस्पैचर टाइमर के साथ टाइमर की तुलना करना मेरी प्रीरीलेज़ ऐप iTunes Connect में एक हफ़्ते से अधिक समय तक "प्रोसेसिंग" रही है, क्या देता है? संस्थाओं / व्यावसायिक वस्तुओं के लिए निर्भरता को हल करने के लिए आईओसी कंटेनर का उपयोग क्यों न करें? एंड्रॉइड: स्क्रीन के नरम कीबोर्ड के साथ केवल दृश्य के हिस्सों का आकार बदलें जावास्क्रिप्ट में केस असंवेदनशील सॉर्ट करने के लिए कैसे करें? jQuery.trigger ('क्लिक') काम नहीं कर रहा है स्पार्क एसक्यूएल में कस्टम टाइप के लिए स्कीमा को कैसे परिभाषित करें? कैसे angularjs में एक http मिल सेवा कैश करने के लिए Java अनुप्रयोग में XML फ़ाइल में पढ़ने का सबसे अच्छा / सरल तरीका क्या है? स्थानीय मेवेन प्रॉक्सी रिपॉजिटरी (नेक्सस) का उपयोग करने के लिए मैं एसबीटी कैसे प्राप्त करूं? हाइबरनेट मानदंड: एक मैप किए गए एसोसिएशन के बिना टेबल में शामिल होना एंड्रॉइड: स्पिनर का संकेत WebBrowser नियंत्रण में JavaScript त्रुटि अक्षम करें क्या "argv = नाम-निष्पादनयोग्य" स्वीकृत मानक या सिर्फ एक आम सम्मेलन है?

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

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

वेब के समाधान से एकत्रित समाधान "स्ट्रिंग की तुलना करते समय केस संवेदनशील होने के लिए 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