एक iOS अनुप्रयोग में Sqlite का उपयोग करते समय LIKE अभिव्यक्ति का अनुकूलन

हाल ही में, मुझे अपने iOS एप्लिकेशन में Sqlite के लिए एक क्वेरी के अनुकूलन के कार्य का सामना करना पड़ा।
कार्य इस प्रकार था। दस्तावेजों की एक सूची थी (पीडीएफ फाइलें), एक शब्दकोश (शब्दों की एक सूची), ठीक है, एक शब्दकोश से दस्तावेजों और शब्दों का एक संबंध (एक दस्तावेज़ में शब्दों का प्रवेश)। एक खोज को लागू करना और दस्तावेजों की एक सूची प्रदर्शित करना आवश्यक था जिसमें एक दर्ज शब्द है।

आधार संरचना इस प्रकार थी:

CREATE TABLE document ( id Int PRIMARY KEY NOT NULL, root_id Int, name Varchar(100), active Tinyint ); CREATE INDEX IDX_documentId ON document (id); CREATE INDEX IDX_documentName ON document (name); CREATE TABLE dictionary ( id Int PRIMARY KEY NOT NULL, word Varchar(100) NOT NULL ); CREATE INDEX IDX_dictionaryId ON dictionary (id); CREATE UNIQUE INDEX IDX_dictionaryWord ON dictionary (word ASC); CREATE TABLE document_index ( id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, document_id Int NOT NULL, word_id Int NOT NULL, FOREIGN KEY(document_id) REFERENCES document(id), FOREIGN KEY(word_id) REFERENCES dictionary(id) ); CREATE INDEX IDX_documentIndexId ON document_index (id); CREATE INDEX IDX_documentIndexDocId ON document_index (document_id); CREATE INDEX IDX_documentIndexWordId ON document_index (word_id); 

निर्दिष्ट शब्दों वाले चयनित अनुभागों में सभी दस्तावेज़ों को पुनः प्राप्त करने के लिए एक क्वेरी:

 SELECT document.id, document.name FROM document INNER JOIN document_index on document_index.document_id=document.id INNER JOIN dictionary on dictionary.id=document_index.word_id WHERE dictionary.word LIKE @pQuery AND document.active = 1 AND document.root_id in (@pRoot1, @pRoot2, @pRoot3, @pRoot4, @pRoot5, @pRoot6, @pRoot7) LIMIT @First, @Count 

आकार विचलन ~ = 400K, दस्तावेज़ ~ = 1K और document_index ~ = 500K प्रविष्टियों के साथ, अनुरोध मेरे iPad 2 पर लगभग 30 सेकंड तक चला, जो मेरे आवेदन के लिए अस्वीकार्य था।

क्वेरी को गति देने के लिए एक समाधान खोजने की प्रक्रिया में, मुझे पता चला कि Sqlite3 में, जब LIKE अभिव्यक्ति का उपयोग करते हैं, तो सूचकांक को ध्यान में नहीं रखा जाता है, जो मेरे रिकॉर्ड के नंबर को देखते हुए बिल्कुल भी अच्छा नहीं था। मैं LIKE का उपयोग करने से भी इनकार नहीं कर सकता था और इसे समानता के लिए तुलनात्मक ऑपरेशन के साथ बदल सकता था, क्योंकि मुझे एक सबस्ट्रिंग खोज की आवश्यकता थी। तब मैंने इस लेख पर ठोकर खाई, इसने सुझाव दिया कि संचालन अभिव्यक्ति के साथ LIKE अभिव्यक्ति> = और <+ याया वर्ण (शब्द अंग्रेजी में बेस शब्द अंग्रेजी में हो तो)।

 /*  */ dictionary.word LIKE '%' /*  */ dictionary.word >= '' AND dictionary.word < '' 

इस अनुकूलन के साथ, खोज के दौरान सूचकांक को ध्यान में रखा जाता है, और 'अबकन' से शुरू होने वाले सभी शब्द पाए जाते हैं। निष्पादन का समय केवल 0.5 सेकंड है! बेशक, सीमाएं हैं, आप एक पंक्ति की शुरुआत से प्रतिस्थापित करके खोज को लागू नहीं कर सकते, अर्थात। किसी भी वर्ण से शुरू होने वाले शब्द और 'अबकान' के साथ समाप्त होते हैं, लेकिन मेरे विशेष मामले में यह आवश्यक नहीं था।