lucene的多种搜索2-SpanQuery

SpanQuery按照词在文章中的距离或者查询几个相邻词的查询

 

SpanQuery包括以下几种：

SpanTermQuery：词距查询的基础，结果和TermQuery相似，只不过是增加了查询结果中单词的距离信息。

SpanFirstQuery：在指定距离可以找到第一个单词的查询。

SpanNearQuery：查询的几个语句之间保持者一定的距离。

SpanOrQuery：同时查询几个词句查询。

SpanNotQuery：从一个词距查询结果中，去除一个词距查询。

下面一个简单例子介绍

package com;

//SpanQuery：跨度查询。此类为抽象类。

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.Token;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.WhitespaceAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Field.Index;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.spans.SpanFirstQuery;
import org.apache.lucene.search.spans.SpanNearQuery;
import org.apache.lucene.search.spans.SpanNotQuery;
import org.apache.lucene.search.spans.SpanOrQuery;
import org.apache.lucene.search.spans.SpanQuery;
import org.apache.lucene.search.spans.SpanTermQuery;
import org.apache.lucene.search.spans.Spans;
import org.apache.lucene.store.RAMDirectory;

public class SpanQueryTest {

	private RAMDirectory directory;

	private IndexSearcher indexSearcher;

	private IndexReader reader;

	private SpanTermQuery quick;

	private SpanTermQuery brown;

	private SpanTermQuery red;

	private SpanTermQuery fox;

	private SpanTermQuery lazy;

	private SpanTermQuery sleepy;

	private SpanTermQuery dog;

	private SpanTermQuery cat;

	private Analyzer analyzer;
	
	// 索引及初使化
	public void index() throws IOException {

		directory = new RAMDirectory();

		analyzer = new WhitespaceAnalyzer();

		IndexWriter writer = new IndexWriter(directory, analyzer, true);

		Document doc1 = new Document();

		doc1.add(new Field("field",
				"the quick brown fox jumps over the lazy dog", Store.YES,
				Index.TOKENIZED));

		Document doc2 = new Document();

		doc2.add(new Field("field",
				"the quick red fox jumps over the sleepy cat", Store.YES,
				Index.TOKENIZED));

		writer.addDocument(doc1);

		writer.addDocument(doc2);

		writer.optimize();

		writer.close();

		quick = new SpanTermQuery(new Term("field", "quick"));

		brown = new SpanTermQuery(new Term("field", "brown"));

		red = new SpanTermQuery(new Term("field", "red"));

		fox = new SpanTermQuery(new Term("field", "fox"));
		lazy = new SpanTermQuery(new Term("field", "lazy"));
		sleepy = new SpanTermQuery(new Term("field", "sleepy"));
		dog = new SpanTermQuery(new Term("field", "dog"));
		cat = new SpanTermQuery(new Term("field", "cat"));

		indexSearcher = new IndexSearcher(directory);

		reader = IndexReader.open(directory);
	}

	private void dumpSpans(SpanQuery query) throws IOException {

		// 检索效果和TermQuery一样,可以把他当成TermQuery
		Hits hits = indexSearcher.search(query);
		for (int i = 0; i < hits.length(); i++) {
			// System.out.println(hits.doc(i).get("field"));
		}

		// 但内部会记录一些位置信息，供SpanQuery的其它API使用，是其它属于SpanQuery的Query的基础。

		Spans spans = query.getSpans(reader);

		int numSpans = 0;

		float[] scores = new float[2];
		for (int i = 0; i < hits.length(); i++) {
			scores[hits.id(i)] = hits.score(i);
		}

		while (spans.next()) {

			numSpans++;

			int id = spans.doc();

			Document doc = reader.document(id);

			Token[] tokens = AnalyzerUtils.tokensFromAnalysis(analyzer, doc
					.get("field"));

			StringBuffer buffer = new StringBuffer();

			for (int i = 0; i < tokens.length; i++) {
				// the quick brown fox jumps over the lazy dog
				// spans记录了位置信息,比如搜索brown,brown在这句话中位于第三个位置,所以spans.start()=2,spans.end()=3
				// 在第二项的位置后加<,第三项后加> 返回<brown>
				if (i == spans.start()) {
					buffer.append("<");
				}
				buffer.append(tokens[i].termText());
				if (i + 1 == spans.end()) {
					buffer.append(">");
				}
				buffer.append(" ");
			}
			buffer.append("(" + scores[id] + ") ");

			System.out.println(buffer);
		}

		// indexSearcher.close();
	}

	// SpanTermQuery：检索效果完全同TermQuery，但内部会记录一些位置信息，供SpanQuery的其它API使用，是其它属于SpanQuery的Query的基础。
	public void spanTermQueryTest() throws IOException {
		dumpSpans(brown);
		
		//// 搜索结果
		// the quick <brown> fox jumps over the lazy dog (0.22097087) 
	}

	// SpanFirstQuery：查找方式为从Field的内容起始位置开始，在一个固定的宽度内查找所指定的词条。
	public void spanFirstQueryTest() throws IOException {
		// the quick brown fox jumps over the lazy dog
		// 在给定的范围搜索,前两个为the quick
		// brown 在doc1的第三个位置,用SpanFirstQuery从起点查找的话,他的跨度必须为>=3才能找到
		SpanFirstQuery firstQuery = new SpanFirstQuery(brown, 3);
		dumpSpans(firstQuery);
		
		////搜索结果
		// the quick <brown> fox jumps over the lazy dog (0.22097087) 
	}

	// SpanNearQuery：功能类似PharaseQuery。SpanNearQuery查找所匹配的不一定是短语，还有可能是另一个SpanQuery的查询结果作为整体考虑，进行嵌套查询。
	public void spanNearQueryTest() throws IOException {
		// the quick brown fox jumps over the lazy dog

		// 第二个参数为两个项的位置之间允许的最大间隔
		// 在这里两个较远的项为quick和fox,他们之是的最大间隔为5,所以slop必须>=5才能搜到结果
		SpanNearQuery nearQuery = new SpanNearQuery(new SpanQuery[] { quick,
				brown, fox }, 5, true);

		dumpSpans(nearQuery);

		// 与PhraseQuery短语搜索相似
		// 这里搜索quick,dog,brown,要想得到结果,就要将brown向后移动5个位置才能到dog的后面,所以slop要>=5才能找到结果
		// 第三个参数,如果为true表示保持各项位置不变,顺序搜索
		nearQuery = new SpanNearQuery(new SpanQuery[] { quick, dog, brown }, 5,
				false);

		dumpSpans(nearQuery);
		
		//////搜索结果/////
		// 第一个dumpSpans的结果 the <quick brown fox> jumps over the lazy dog (0.34204215) 
		// 第二个dumpSpans的结果 the <quick brown fox jumps over the lazy dog> (0.27026406) 
	}

	// 从第一个SpanQuery查询结果中，去掉第二个SpanQuery查询结果，作为检索结果
	public void spanNotQueryTest() throws IOException {
		
		// the quick brown fox jumps over the lazy dog

		SpanNearQuery quick_fox = new SpanNearQuery(new SpanQuery[] { quick,
				fox }, 1, true);

		// 结果为quick brown fox 和 quick red fox
		dumpSpans(quick_fox);

		// SpanNotQuery quick_fox_dog = new SpanNotQuery(quick_fox, dog);
		//
		// dumpSpans(quick_fox_dog);

		// 在quick_fox结果中,去掉red,结果为quick brown fox
		SpanNotQuery no_quick_red_fox = new SpanNotQuery(quick_fox, red);

		dumpSpans(no_quick_red_fox);
		
		//////搜索结果///////第一个dumpSpans结果为前两条,第二个dumpSpans结果为第三条
		//the <quick brown fox> jumps over the lazy dog (0.18579213) 
		//the <quick red fox> jumps over the sleepy cat (0.18579213) 
		//the <quick brown fox> jumps over the lazy dog (0.18579213) 
	}

	// SpanOrQuery：把所有SpanQuery查询结果综合起来，作为检索结果。
	public void spanOrQueryTest() throws IOException   {
		
		SpanNearQuery quick_fox = new SpanNearQuery(new SpanQuery[] { quick,
				fox }, 1, true);
		
		SpanNearQuery lazy_dog = new SpanNearQuery(
				new SpanQuery[] { lazy, dog }, 0, true);

		SpanNearQuery sleepy_cat = new SpanNearQuery(new SpanQuery[] { sleepy,
				cat }, 0, true);

		SpanNearQuery qf_near_ld = new SpanNearQuery(new SpanQuery[] {
				quick_fox, lazy_dog }, 3, true);
		
		dumpSpans(qf_near_ld);

		SpanNearQuery qf_near_sc = new SpanNearQuery(new SpanQuery[] {
				quick_fox, sleepy_cat }, 3, true);
		
		dumpSpans(qf_near_sc);

		SpanOrQuery or = new SpanOrQuery(new SpanQuery[] { qf_near_ld,
				qf_near_sc });
		
		dumpSpans(or);
		
		/////////搜索结果 第一个dumpSpans结果为第一条,第二个为第二条,第三个为第三,四条
		// the <quick brown fox jumps over the lazy dog> (0.3321948) 
		// the <quick red fox jumps over the sleepy cat> (0.3321948) 
		// the <quick brown fox jumps over the lazy dog> (0.5405281) 
		// the <quick red fox jumps over the sleepy cat> (0.5405281) 
	}

	public static void main(String[] args) throws IOException {

		SpanQueryTest test = new SpanQueryTest();

		test.index();

		test.spanOrQueryTest();
	}
}

class AnalyzerUtils {
	public static Token[] tokensFromAnalysis(Analyzer analyzer, String text)
			throws IOException {
		TokenStream stream = analyzer.tokenStream("contents", new StringReader(
				text));
		boolean b = true;
		List<Token> list = new ArrayList<Token>();
		while (b) {
			Token token = stream.next();
			if (token == null)
				b = false;
			else
				list.add(token);
		}
		return (Token[]) list.toArray(new Token[0]);
	}
}