Trouver la position des résultats de recherche à partir de Lucene

Avec Lucene, quelle serait l'approche recommandée pour la localisation des matchs dans les résultats de recherche?

Plus précisément, supposons que l'indice de documents ont un champ "texte intégral", qui enregistre la plaine-le contenu du texte d'un document. En outre, supposons que pour un de ces documents, le contenu est "The quick brown fox jumps over the lazy dog". Suivant une recherche est effectuée pour "fox chien". Évidemment, le document serait un succès.

Dans ce scénario, peut Lucene être utilisé pour fournir quelque chose comme la mise en correspondance des régions pour les documents trouvés? Donc, pour ce scénario, je voudrais produire quelque chose comme:

[{match: "fox", startIndex: 10, length: 3},
 {match: "dog", startIndex: 34, length: 3}]

Je soupçonne qu'il pourrait être mis en œuvre par ce qui est fourni dans le org.apache.lucene.de recherche.un ensemble de moments forts. Je ne suis pas sûr au sujet de l'approche globale...

OriginalL'auteur VoidPointer | 2009-08-21

  1. 10

    TermFreqVector est ce que j'ai utilisé. Ici, c'est un travail de démonstration, qui imprime à la fois le terme de positions, et le début et la fin à terme d'indices:

    public class Search {
public static void main(String[] args) throws IOException, ParseException {
Search s = new Search();  
s.doSearch(args[0], args[1]);  
}  
Search() {
}  
public void doSearch(String db, String querystr) throws IOException, ParseException {
//1. Specify the analyzer for tokenizing text.  
//   The same analyzer should be used as was used for indexing  
StandardAnalyzer analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);  
Directory index = FSDirectory.open(new File(db));  
//2. query  
Query q = new QueryParser(Version.LUCENE_CURRENT, "contents", analyzer).parse(querystr);  
//3. search  
int hitsPerPage = 10;  
IndexSearcher searcher = new IndexSearcher(index, true);  
IndexReader reader = IndexReader.open(index, true);  
searcher.setDefaultFieldSortScoring(true, false);  
TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerPage, true);  
searcher.search(q, collector);  
ScoreDoc[] hits = collector.topDocs().scoreDocs;  
//4. display term positions, and term indexes   
System.out.println("Found " + hits.length + " hits.");  
for(int i=0;i<hits.length;++i) {  
int docId = hits[i].doc;  
TermFreqVector tfvector = reader.getTermFreqVector(docId, "contents");  
TermPositionVector tpvector = (TermPositionVector)tfvector;  
//this part works only if there is one term in the query string,  
//otherwise you will have to iterate this section over the query terms.  
int termidx = tfvector.indexOf(querystr);  
int[] termposx = tpvector.getTermPositions(termidx);  
TermVectorOffsetInfo[] tvoffsetinfo = tpvector.getOffsets(termidx);  
for (int j=0;j<termposx.length;j++) {  
System.out.println("termpos : "+termposx[j]);  
}  
for (int j=0;j<tvoffsetinfo.length;j++) {  
int offsetStart = tvoffsetinfo[j].getStartOffset();  
int offsetEnd = tvoffsetinfo[j].getEndOffset();  
System.out.println("offsets : "+offsetStart+" "+offsetEnd);  
}  
//print some info about where the hit was found...  
Document d = searcher.doc(docId);  
System.out.println((i + 1) + ". " + d.get("path"));  
}  
//searcher can only be closed when there  
//is no need to access the documents any more.   
searcher.close();  
}      
}
    Le commentaire "cette partie ne fonctionne que si il y a un terme en thr de la chaîne de requête". Ma prochaine question est: comment trouver les termes qui sont appariés par la requête (si c'est une requête complexe (par exemple, avec des caractères génériques). Cette réponse bien remplit cette lacune: stackoverflow.com/questions/7896183/...

    OriginalL'auteur Allasso

  2. 3

    Voici une solution pour lucene 5.2.1. Il ne fonctionne que pour un seul mot des requêtes sur, mais doit démontrer les principes de base.

    L'idée de base est:

    1. Obtenir un TokenStream pour chaque document, ce qui correspond à votre requête.
    2. Créer un QueryScorer et de l'initialiser avec la récupérées tokenStream.
    3. "En boucle" sur chaque jeton du flux (fait par tokenStream.incrementToken()) et vérifier si le jeton correspond aux critères de recherche (fait par queryScorer.getTokenScore()).

    Voici le code:

    import java.io.IOException;
import java.util.List;
import java.util.Vector;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.de.GermanAnalyzer;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.highlight.InvalidTokenOffsetsException;
import org.apache.lucene.search.highlight.QueryScorer;
import org.apache.lucene.search.highlight.TokenSources;
public class OffsetSearcher {
private IndexReader reader;
public OffsetSearcher(IndexWriter indexWriter) throws IOException { 
reader = DirectoryReader.open(indexWriter, true); 
}
public OffsetData[] getTermOffsets(Query query) throws IOException, InvalidTokenOffsetsException 
{
List<OffsetData> result = new Vector<>();
IndexSearcher searcher = new IndexSearcher(reader);
TopDocs topDocs = searcher.search(query, 1000);
ScoreDoc[] scoreDocs = topDocs.scoreDocs;   
Document doc;
TokenStream tokenStream;
CharTermAttribute termAtt;
OffsetAttribute offsetAtt;
QueryScorer queryScorer;
OffsetData offsetData;
String txt, tokenText;
for (int i = 0; i < scoreDocs.length; i++) 
{
int docId = scoreDocs[i].doc;
doc = reader.document(docId);
txt = doc.get(RunSearch.CONTENT);
tokenStream = TokenSources.getTokenStream(RunSearch.CONTENT, reader.getTermVectors(docId), txt, new GermanAnalyzer(), -1);
termAtt = (CharTermAttribute)tokenStream.addAttribute(CharTermAttribute.class);
offsetAtt = (OffsetAttribute)tokenStream.addAttribute(OffsetAttribute.class);
queryScorer = new QueryScorer(query);
queryScorer.setMaxDocCharsToAnalyze(RunSearch.MAX_DOC_CHARS);
TokenStream newStream  = queryScorer.init(tokenStream);
if (newStream != null) {
tokenStream = newStream;
}
queryScorer.startFragment(null);
tokenStream.reset();
int startOffset, endOffset;
for (boolean next = tokenStream.incrementToken(); next && (offsetAtt.startOffset() < RunSearch.MAX_DOC_CHARS); next = tokenStream.incrementToken())
{
startOffset = offsetAtt.startOffset();
endOffset = offsetAtt.endOffset();
if ((endOffset > txt.length()) || (startOffset > txt.length()))
{
throw new InvalidTokenOffsetsException("Token " + termAtt.toString() + " exceeds length of provided text sized " + txt.length());
}
float res = queryScorer.getTokenScore();
if (res > 0.0F && startOffset <= endOffset) {
tokenText = txt.substring(startOffset, endOffset);
offsetData = new OffsetData(tokenText, startOffset, endOffset, docId);
result.add(offsetData);
}           
}   
}
return result.toArray(new OffsetData[result.size()]);
}
public void close() throws IOException {
reader.close();
}
public static class OffsetData {
public String phrase;
public int startOffset;
public int endOffset;
public int docId;
public OffsetData(String phrase, int startOffset, int endOffset, int docId) {
super();
this.phrase = phrase;
this.startOffset = startOffset;
this.endOffset = endOffset;
this.docId = docId;
}
}
}
    Pourriez-vous dire comment faire pour le mettre en œuvre pour les requêtes multi-termes? @matthiasboesinger

    OriginalL'auteur matthiasboesinger