lucene的多种搜索2-SpanQuery

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

 

SpanQuery包括以下几种：

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

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

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

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

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

下面一个简单例子介绍

Java代码

1. package com;   
2.   
3. //SpanQuery：跨度查询。此类为抽象类。   
4.   
5. import java.io.IOException;   
6. import java.io.StringReader;   
7. import java.util.ArrayList;   
8. import java.util.List;   
9. import org.apache.lucene.analysis.Analyzer;   
10. import org.apache.lucene.analysis.Token;   
11. import org.apache.lucene.analysis.TokenStream;   
12. import org.apache.lucene.analysis.WhitespaceAnalyzer;   
13. import org.apache.lucene.document.Document;   
14. import org.apache.lucene.document.Field;   
15. import org.apache.lucene.document.Field.Index;   
16. import org.apache.lucene.document.Field.Store;   
17. import org.apache.lucene.index.IndexReader;   
18. import org.apache.lucene.index.IndexWriter;   
19. import org.apache.lucene.index.Term;   
20. import org.apache.lucene.search.Hits;   
21. import org.apache.lucene.search.IndexSearcher;   
22. import org.apache.lucene.search.spans.SpanFirstQuery;   
23. import org.apache.lucene.search.spans.SpanNearQuery;   
24. import org.apache.lucene.search.spans.SpanNotQuery;   
25. import org.apache.lucene.search.spans.SpanOrQuery;   
26. import org.apache.lucene.search.spans.SpanQuery;   
27. import org.apache.lucene.search.spans.SpanTermQuery;   
28. import org.apache.lucene.search.spans.Spans;   
29. import org.apache.lucene.store.RAMDirectory;   
30.   
31. public class SpanQueryTest {   
32.   
33.     private RAMDirectory directory;   
34.   
35.     private IndexSearcher indexSearcher;   
36.   
37.     private IndexReader reader;   
38.   
39.     private SpanTermQuery quick;   
40.   
41.     private SpanTermQuery brown;   
42.   
43.     private SpanTermQuery red;   
44.   
45.     private SpanTermQuery fox;   
46.   
47.     private SpanTermQuery lazy;   
48.   
49.     private SpanTermQuery sleepy;   
50.   
51.     private SpanTermQuery dog;   
52.   
53.     private SpanTermQuery cat;   
54.   
55.     private Analyzer analyzer;   
56.        
57.     // 索引及初使化   
58.     public void index() throws IOException {   
59.   
60.         directory = new RAMDirectory();   
61.   
62.         analyzer = new WhitespaceAnalyzer();   
63.   
64.         IndexWriter writer = new IndexWriter(directory, analyzer, true);   
65.   
66.         Document doc1 = new Document();   
67.   
68.         doc1.add(new Field("field",   
69.                 "the quick brown fox jumps over the lazy dog", Store.YES,   
70.                 Index.TOKENIZED));   
71.   
72.         Document doc2 = new Document();   
73.   
74.         doc2.add(new Field("field",   
75.                 "the quick red fox jumps over the sleepy cat", Store.YES,   
76.                 Index.TOKENIZED));   
77.   
78.         writer.addDocument(doc1);   
79.   
80.         writer.addDocument(doc2);   
81.   
82.         writer.optimize();   
83.   
84.         writer.close();   
85.   
86.         quick = new SpanTermQuery(new Term("field", "quick"));   
87.   
88.         brown = new SpanTermQuery(new Term("field", "brown"));   
89.   
90.         red = new SpanTermQuery(new Term("field", "red"));   
91.   
92.         fox = new SpanTermQuery(new Term("field", "fox"));   
93.         lazy = new SpanTermQuery(new Term("field", "lazy"));   
94.         sleepy = new SpanTermQuery(new Term("field", "sleepy"));   
95.         dog = new SpanTermQuery(new Term("field", "dog"));   
96.         cat = new SpanTermQuery(new Term("field", "cat"));   
97.   
98.         indexSearcher = new IndexSearcher(directory);   
99.   
100.         reader = IndexReader.open(directory);   
101.     }   
102.   
103.     private void dumpSpans(SpanQuery query) throws IOException {   
104.   
105.         // 检索效果和TermQuery一样,可以把他当成TermQuery   
106.         Hits hits = indexSearcher.search(query);   
107.         for (int i = 0; i < hits.length(); i++) {   
108.             // System.out.println(hits.doc(i).get("field"));   
109.         }   
110.   
111.         // 但内部会记录一些位置信息，供SpanQuery的其它API使用，是其它属于SpanQuery的Query的基础。   
112.   
113.         Spans spans = query.getSpans(reader);   
114.   
115.         int numSpans = 0;   
116.   
117.         float[] scores = new float[2];   
118.         for (int i = 0; i < hits.length(); i++) {   
119.             scores[hits.id(i)] = hits.score(i);   
120.         }   
121.   
122.         while (spans.next()) {   
123.   
124.             numSpans++;   
125.   
126.             int id = spans.doc();   
127.   
128.             Document doc = reader.document(id);   
129.   
130.             Token[] tokens = AnalyzerUtils.tokensFromAnalysis(analyzer, doc   
131.                     .get("field"));   
132.   
133.             StringBuffer buffer = new StringBuffer();   
134.   
135.             for (int i = 0; i < tokens.length; i++) {   
136.                 // the quick brown fox jumps over the lazy dog   
137.                 // spans记录了位置信息,比如搜索brown,brown在这句话中位于第三个位置,所以spans.start()=2,spans.end()=3   
138.                 // 在第二项的位置后加<,第三项后加> 返回<brown>   
139.                 if (i == spans.start()) {   
140.                     buffer.append("<");   
141.                 }   
142.                 buffer.append(tokens[i].termText());   
143.                 if (i + 1 == spans.end()) {   
144.                     buffer.append(">");   
145.                 }   
146.                 buffer.append(" ");   
147.             }   
148.             buffer.append("(" + scores[id] + ") ");   
149.   
150.             System.out.println(buffer);   
151.         }   
152.   
153.         // indexSearcher.close();   
154.     }   
155.   
156.     // SpanTermQuery：检索效果完全同TermQuery，但内部会记录一些位置信息，供SpanQuery的其它API使用，是其它属于SpanQuery的Query的基础。   
157.     public void spanTermQueryTest() throws IOException {   
158.         dumpSpans(brown);   
159.            
160.          搜索结果   
161.         // the quick <brown> fox jumps over the lazy dog (0.22097087)    
162.     }   
163.   
164.     // SpanFirstQuery：查找方式为从Field的内容起始位置开始，在一个固定的宽度内查找所指定的词条。   
165.     public void spanFirstQueryTest() throws IOException {   
166.         // the quick brown fox jumps over the lazy dog   
167.         // 在给定的范围搜索,前两个为the quick   
168.         // brown 在doc1的第三个位置,用SpanFirstQuery从起点查找的话,他的跨度必须为>=3才能找到   
169.         SpanFirstQuery firstQuery = new SpanFirstQuery(brown, 3);   
170.         dumpSpans(firstQuery);   
171.            
172.         搜索结果   
173.         // the quick <brown> fox jumps over the lazy dog (0.22097087)    
174.     }   
175.   
176.     // SpanNearQuery：功能类似PharaseQuery。SpanNearQuery查找所匹配的不一定是短语，还有可能是另一个SpanQuery的查询结果作为整体考虑，进行嵌套查询。   
177.     public void spanNearQueryTest() throws IOException {   
178.         // the quick brown fox jumps over the lazy dog   
179.   
180.         // 第二个参数为两个项的位置之间允许的最大间隔   
181.         // 在这里两个较远的项为quick和fox,他们之是的最大间隔为5,所以slop必须>=5才能搜到结果   
182.         SpanNearQuery nearQuery = new SpanNearQuery(new SpanQuery[] { quick,   
183.                 brown, fox }, 5, true);   
184.   
185.         dumpSpans(nearQuery);   
186.   
187.         // 与PhraseQuery短语搜索相似   
188.         // 这里搜索quick,dog,brown,要想得到结果,就要将brown向后移动5个位置才能到dog的后面,所以slop要>=5才能找到结果   
189.         // 第三个参数,如果为true表示保持各项位置不变,顺序搜索   
190.         nearQuery = new SpanNearQuery(new SpanQuery[] { quick, dog, brown }, 5,   
191.                 false);   
192.   
193.         dumpSpans(nearQuery);   
194.            
195.         //搜索结果/   
196.         // 第一个dumpSpans的结果 the <quick brown fox> jumps over the lazy dog (0.34204215)    
197.         // 第二个dumpSpans的结果 the <quick brown fox jumps over the lazy dog> (0.27026406)    
198.     }   
199.   
200.     // 从第一个SpanQuery查询结果中，去掉第二个SpanQuery查询结果，作为检索结果   
201.     public void spanNotQueryTest() throws IOException {   
202.            
203.         // the quick brown fox jumps over the lazy dog   
204.   
205.         SpanNearQuery quick_fox = new SpanNearQuery(new SpanQuery[] { quick,   
206.                 fox }, 1, true);   
207.   
208.         // 结果为quick brown fox 和 quick red fox   
209.         dumpSpans(quick_fox);   
210.   
211.         // SpanNotQuery quick_fox_dog = new SpanNotQuery(quick_fox, dog);   
212.         //   
213.         // dumpSpans(quick_fox_dog);   
214.   
215.         // 在quick_fox结果中,去掉red,结果为quick brown fox   
216.         SpanNotQuery no_quick_red_fox = new SpanNotQuery(quick_fox, red);   
217.   
218.         dumpSpans(no_quick_red_fox);   
219.            
220.         //搜索结果///第一个dumpSpans结果为前两条,第二个dumpSpans结果为第三条   
221.         //the <quick brown fox> jumps over the lazy dog (0.18579213)    
222.         //the <quick red fox> jumps over the sleepy cat (0.18579213)    
223.         //the <quick brown fox> jumps over the lazy dog (0.18579213)    
224.     }   
225.   
226.     // SpanOrQuery：把所有SpanQuery查询结果综合起来，作为检索结果。   
227.     public void spanOrQueryTest() throws IOException   {   
228.            
229.         SpanNearQuery quick_fox = new SpanNearQuery(new SpanQuery[] { quick,   
230.                 fox }, 1, true);   
231.            
232.         SpanNearQuery lazy_dog = new SpanNearQuery(   
233.                 new SpanQuery[] { lazy, dog }, 0, true);   
234.   
235.         SpanNearQuery sleepy_cat = new SpanNearQuery(new SpanQuery[] { sleepy,   
236.                 cat }, 0, true);   
237.   
238.         SpanNearQuery qf_near_ld = new SpanNearQuery(new SpanQuery[] {   
239.                 quick_fox, lazy_dog }, 3, true);   
240.            
241.         dumpSpans(qf_near_ld);   
242.   
243.         SpanNearQuery qf_near_sc = new SpanNearQuery(new SpanQuery[] {   
244.                 quick_fox, sleepy_cat }, 3, true);   
245.            
246.         dumpSpans(qf_near_sc);   
247.   
248.         SpanOrQuery or = new SpanOrQuery(new SpanQuery[] { qf_near_ld,   
249.                 qf_near_sc });   
250.            
251.         dumpSpans(or);   
252.            
253.         /搜索结果 第一个dumpSpans结果为第一条,第二个为第二条,第三个为第三,四条   
254.         // the <quick brown fox jumps over the lazy dog> (0.3321948)    
255.         // the <quick red fox jumps over the sleepy cat> (0.3321948)    
256.         // the <quick brown fox jumps over the lazy dog> (0.5405281)    
257.         // the <quick red fox jumps over the sleepy cat> (0.5405281)    
258.     }   
259.   
260.     public static void main(String[] args) throws IOException {   
261.   
262.         SpanQueryTest test = new SpanQueryTest();   
263.   
264.         test.index();   
265.   
266.         test.spanOrQueryTest();   
267.     }   
268. }   
269.   
270. class AnalyzerUtils {   
271.     public static Token[] tokensFromAnalysis(Analyzer analyzer, String text)   
272.             throws IOException {   
273.         TokenStream stream = analyzer.tokenStream("contents", new StringReader(   
274.                 text));   
275.         boolean b = true;   
276.         List<Token> list = new ArrayList<Token>();   
277.         while (b) {   
278.             Token token = stream.next();   
279.             if (token == null)   
280.                 b = false;   
281.             else  
282.                 list.add(token);   
283.         }   
284.         return (Token[]) list.toArray(new Token[0]);   
285.     }   
286. }  

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]);
	}
}