लुसेन

Question

में विशेष वर्णों (+! \?:) को कैसे खोजें I अनुक्रमणिका में विशेष वर्ण खोजना चाहते हैं।

मैं क्वेरी स्ट्रिंग में सभी विशेष पात्रों से बच निकला लेकिन जब मैं इंडेक्स में ल्यूसीन पर + के रूप में क्वेरी करता हूं तो यह क्वेरी (+) के रूप में बनाता है।

इसलिए यह कोई फ़ील्ड नहीं खोजता है।

इस समस्या को हल करने के लिए कैसे करें? मेरी अनुक्रमणिका में इन विशेष पात्र हैं।

Answer 1

यदि आप StandardAnalyzer का उपयोग कर रहे हैं, तो यह गैर-अल्फानम वर्णों को त्याग देगा। WhitespaceAnalyzer के साथ समान मान को अनुक्रमणित करने का प्रयास करें और देखें कि क्या आपको आवश्यक वर्णों को संरक्षित किया गया है या नहीं। यह उन सामानों को भी रख सकता है जिन्हें आप नहीं चाहते हैं: यही वह समय है जब आप अपने स्वयं के विश्लेषक लिखने पर विचार कर सकते हैं, जिसका मूल रूप से टोकनस्ट्रीम स्टैक बनाना है जो वास्तव में आपको जिस प्रकार की प्रोसेसिंग की आवश्यकता है।

उदाहरण के लिए, SimpleAnalyzer लागू करता है निम्नलिखित पाइपलाइन:

@Override 
public TokenStream tokenStream(String fieldName, Reader reader) { 
    return new LowerCaseTokenizer(reader); 
} 

जो सिर्फ कम मामलों टोकन।

StandardAnalyzer भी बहुत कुछ करता है:

/** Constructs a {@link StandardTokenizer} filtered by a {@link 
StandardFilter}, a {@link LowerCaseFilter} and a {@link StopFilter}. */ 
@Override 
public TokenStream tokenStream(String fieldName, Reader reader) { 
    StandardTokenizer tokenStream = new StandardTokenizer(matchVersion, reader); 
    tokenStream.setMaxTokenLength(maxTokenLength); 
    TokenStream result = new StandardFilter(tokenStream); 
    result = new LowerCaseFilter(result); 
    result = new StopFilter(enableStopPositionIncrements, result, stopSet); 
    return result; 
} 

आप org.apache.lucene.analysis में इन और अन्य घटकों से & मैच मिश्रण कर सकते हैं, या आप अपने स्वयं विशेष TokenStream उदाहरणों कि अपने कस्टम Analyzer द्वारा एक प्रोसेसिंग पाइपलाइन में लपेटा जाता है लिख सकते हैं ।

एक और बात यह देखने के लिए है कि CharTokenizer आप किस प्रकार का उपयोग कर रहे हैं। CharTokenizer एक अमूर्त वर्ग है जो टोकनिंग टेक्स्ट स्ट्रिंग के लिए मशीनरी निर्दिष्ट करता है। इसका उपयोग कुछ सरल विश्लेषकों द्वारा किया जाता है (लेकिन StandardAnalyzer द्वारा नहीं)। ल्यूसीन दो उप-वर्गों के साथ आता है: LetterTokenizer और WhitespaceTokenizer। आप अपना खुद का निर्माण कर सकते हैं जो आपको आवश्यक अक्षरों को रखता है और boolean isTokenChar(char c) विधि को लागू करके उन पर टूट जाता है।

1. कस्टम विश्लेषक बनाएं
2. अनुक्रमण के लिए यह प्रयोग करें और खोज

उदाहरण है कि यह कैसे काम करता है:

Answer 2

शायद यह लेखक के लिए वास्तविक लेकिन विशेष वर्ण खोज करने के लिए आप की जरूरत सक्षम होने के लिए नहीं है मेरे लिए:

import org.apache.lucene.analysis.Analyzer; 
import org.apache.lucene.analysis.custom.CustomAnalyzer; 
import org.apache.lucene.document.Document; 
import org.apache.lucene.document.Field; 
import org.apache.lucene.document.TextField; 
import org.apache.lucene.index.DirectoryReader; 
import org.apache.lucene.index.IndexReader; 
import org.apache.lucene.index.IndexWriter; 
import org.apache.lucene.index.IndexWriterConfig; 
import org.apache.lucene.queryparser.classic.QueryParser; 
import org.apache.lucene.search.*; 
import org.apache.lucene.store.RAMDirectory; 
import org.junit.Test; 

import java.io.IOException; 

import static org.hamcrest.Matchers.equalTo; 
import static org.junit.Assert.assertThat; 

public class LuceneSpecialCharactersSearchTest { 

/** 
* Test that tries to search a string by some substring with each special character separately. 
*/ 
@Test 
public void testSpecialCharacterSearch() throws Exception { 
    // GIVEN 
    LuceneSpecialCharactersSearch service = new LuceneSpecialCharactersSearch(); 
    String[] luceneSpecialCharacters = new String[]{"+", "-", "&&", "||", "!", "(", ")", "{", "}", "[", "]", "^", "\"", "~", "*", "?", ":", "\\"}; 

    // WHEN 
    for (String specialCharacter : luceneSpecialCharacters) { 
     String actual = service.search("list's special-characters " + specialCharacter); 

     // THEN 
     assertThat(actual, equalTo(LuceneSpecialCharactersSearch.TEXT_WITH_SPECIAL_CHARACTERS)); 
    } 
} 

private static class LuceneSpecialCharactersSearch { 
    private static final String TEXT_WITH_SPECIAL_CHARACTERS = "This is the list's of special-characters + - && || ! () { } [ ]^\" ~ ? : \\ *"; 

    private final IndexWriter writer; 

    public LuceneSpecialCharactersSearch() throws Exception { 
     Document document = new Document(); 
     document.add(new TextField("body", TEXT_WITH_SPECIAL_CHARACTERS, Field.Store.YES)); 

     RAMDirectory directory = new RAMDirectory(); 
     writer = new IndexWriter(directory, new IndexWriterConfig(buildAnalyzer())); 
     writer.addDocument(document); 
     writer.commit(); 
    } 

    public String search(String queryString) throws Exception { 
     try (IndexReader reader = DirectoryReader.open(writer, false)) { 
      IndexSearcher searcher = new IndexSearcher(reader); 

      String escapedQueryString = QueryParser.escape(queryString).toLowerCase(); 

      Analyzer analyzer = buildAnalyzer(); 
      QueryParser bodyQueryParser = new QueryParser("body", analyzer); 
      bodyQueryParser.setDefaultOperator(QueryParser.Operator.AND); 


      Query bodyQuery = bodyQueryParser.parse(escapedQueryString); 
      BooleanQuery query = new BooleanQuery.Builder() 
        .add(new BooleanClause(bodyQuery, BooleanClause.Occur.SHOULD)) 
        .build(); 
      TopDocs searchResult = searcher.search(query, 1); 

      return searcher.doc(searchResult.scoreDocs[0].doc).getField("body").stringValue(); 
     } 
    } 

    /** 
    * Builds analyzer that is used for indexing and searching. 
    */ 
    private static Analyzer buildAnalyzer() throws IOException { 
     return CustomAnalyzer.builder() 
       .withTokenizer("whitespace") 
       .addTokenFilter("lowercase") 
       .addTokenFilter("standard") 
       .build(); 

    } 
} 
}