本文是我們名為“ Apache Lucene基礎(chǔ)知識 ”的學(xué)院課程的一部分。

在本課程中，您將了解Lucene。 您將了解為什么這樣的庫很重要，然后了解Lucene中搜索的工作方式。 此外，您將學(xué)習(xí)如何將Lucene Search集成到您自己的應(yīng)用程序中，以提供強(qiáng)大的搜索功能。 在這里查看 ！

目錄

1.引言 2.Lucene查詢 3，Lucene查詢API 4，基本搜索

4.1。條款 4.2。通配符查詢 4.3。布爾運(yùn)算符 4.3分組 4.4。短語查詢 4.5。范圍查詢 4.6。前綴查詢 4.7。模糊查詢

1.引言

在上一章中，我們了解了Lucene搜索引擎的不同組件 。 我們還使用lucene索引和搜索程序構(gòu)建了一個小型搜索應(yīng)用程序。 在本章中，我們將討論Lucene查詢。

2.Lucene查詢

Lucene具有用于查詢其索引的自定義查詢語法。 查詢分為術(shù)語和運(yùn)算符。 術(shù)語有兩種類型： 1 . 單詞和2.短語 。 單個術(shù)語是一個單詞，例如“測試”或“樣本”。 詞組是一組用雙引號括起來的單詞，例如“ welcome lucene”。 可以將多個術(shù)語與布爾運(yùn)算符組合在一起以形成更復(fù)雜的查詢。 對于Lucene Java，TermQuery是最原始的查詢。 然后是BooleanQuery，PhraseQuery和許多其他Query子類可供選擇。

字段執(zhí)行搜索時，我們可以指定要搜索的字段。任何現(xiàn)有的字段名稱都可以用作字段名稱。 語法為FieldName：VALUE 。 有一些特殊的字段類型具有自己的語法來定義查詢詞。 例如，DateTime：ModificationDate：>'2010-09-01 12:00:00'我們將在后面的部分中解釋對這些字段的搜索操作。

3，Lucene查詢API

當(dāng)Lucene的QueryParser解析人類可讀的查詢時，它將轉(zhuǎn)換為Query類的單個具體子類。 我們需要對基礎(chǔ)的具體Query子類有所了解。 下表列出了相關(guān)的子類，它們的用途以及一些示例表達(dá)式：

查詢實(shí)施目的樣本表達(dá)

TermQuery	單項(xiàng)查詢，實(shí)際上是一個單詞。	雷諾
PhraseQuery	多個項(xiàng)按順序排列或彼此接近的匹配項(xiàng)	“前方點(diǎn)亮”
RangeQuery	用開始和結(jié)束詞之間的詞匹配文檔，包括或不包括端點(diǎn)。	[A到Z] {A到Z}
WildcardQuery	輕量級的，類似于正則表達(dá)式的術(shù)語匹配語法。	j * v？ f ?? bar
PrefixQuery	匹配以指定字符串開頭的所有術(shù)語。	起司*
FuzzyQuery	Levenshtein緊密匹配算法。	樹?
BooleanQuery	將其他查詢實(shí)例聚合為允許AND，OR和NOT邏輯的復(fù)雜表達(dá)式。	雷諾和“前方點(diǎn)亮” 奶酪*-奶酪

所有這些Query實(shí)現(xiàn)都在org.apache.lucene.search包中。 BooleanQuery是一種特殊情況，因?yàn)樗且粋€聚合其他查詢（包括用于復(fù)雜表達(dá)式的嵌套BooleanQuery ）的Query容器。

這是一個基于查詢片段的BooleanQuery 。 在這里，我們可以看到QueryParser創(chuàng)建的查詢與API創(chuàng)建的查詢等效：

public class RulezTest extends TestCase { public void testJavaNotDotNet() throws Exception { BooleanQuery apiQuery = new BooleanQuery(); apiQuery.add(new TermQuery(new Term("contents", "java")), true, false); apiQuery.add(new TermQuery(new Term("contents", "net")), true, false); apiQuery.add(new TermQuery(new Term("contents", "dot")), false, true); Query qpQuery = QueryParser.parse("java AND net NOT dot", "contents", new StandardAnalyzer()); // Query and subclasses behave as expected with .equals assertEquals(qpQuery, apiQuery); } }

Query類的一些有趣的功能是它們的toString方法。 每個Query子類都會生成等效的QueryParserexpression （盡管不一定在文本上精確）。 有兩種變體：一種是標(biāo)準(zhǔn)的Object.toString重寫方法，另一種接受默認(rèn)字段名稱。 下面的測試案例演示了這兩種方法的工作原理，并說明了如何返回等效（但不是確切）的表達(dá)式。

public void testToString() throws Exception { Query query = QueryParser.parse("java AND net NOT dot", "contents", new StandardAnalyzer()); assertEquals("+java +net -dot", query.toString("contents")); assertEquals("+contents:java +contents:net -contents:dot", query.toString()); }

注意，解析的表達(dá)式是“ java AND net NOT dot”，但是從toString方法返回的表達(dá)式使用了縮寫語法“ + java + net -dot”。 我們的第一個測試用例（ testJavaNotDotNet ）證明了底層查詢對象本身是等效的。

no-arg toString方法不對每個術(shù)語的字段名稱做任何假設(shè)，并使用字段選擇器語法明確指定它們。 使用這些toString方法可方便地診斷QueryParser問題。

4，基本搜索

在大多數(shù)情況下，您要查找單個術(shù)語或短語，即由雙引號引起的一組單詞（“示例應(yīng)用程序”）。 在這些情況下，我們將在其默認(rèn)索引數(shù)據(jù)中查找包含這些單詞的內(nèi)容，這些內(nèi)容包含內(nèi)容的所有相關(guān)文本。

在更復(fù)雜的情況下，我們可能需要根據(jù)要查找的內(nèi)容的類型或位置進(jìn)行某些過濾，或者我們要在特定字段中進(jìn)行搜索。 在這里，我們可以學(xué)習(xí)如何構(gòu)建更復(fù)雜的查詢，這些查詢可用于有效地在大型存儲庫中查找內(nèi)容。

4.1。條款

假設(shè)我們要在標(biāo)簽字段中使用關(guān)鍵字“博客”進(jìn)行搜索。 語法將是

tag : blog

現(xiàn)在，我們將在標(biāo)簽字段中使用短語“ lucene blog”進(jìn)行搜索。 為此，語法將是

tag : "lucene blog"

現(xiàn)在，讓我們在標(biāo)簽字段中搜索“ lucene blog”，然后在正文中搜索“ technical blog”，

tag : "lucene blog" AND body : "technical blog"

假設(shè)我們要在標(biāo)簽字段中搜索短語“ lucene blog”，在正文中搜索“技術(shù)博客”，或者在標(biāo)簽字段中搜索“ searching blog”，

(tag : "lucene blog" AND body : "technical blog") OR tag : "searching blog"

如果我們要在標(biāo)記字段中搜索“博客”而不是“ lucene”，則語法看起來會相似，

tag : blog -tag : lucene

4.2。通配符查詢

Lucene支持在單個術(shù)語內(nèi)（而不是在短語查詢中）單字符和多字符通配符搜索。

要執(zhí)行單個字符通配符搜索，請使用“？” 符號。

要執(zhí)行多字符通配符搜索，請使用“ *”符號。

單字符通配符搜索查找與替換了單個字符的詞匹配的術(shù)語。 例如，要搜索“文本”或“測試”，我們可以使用搜索：te？t

多字符通配符搜索將查找0個或多個字符。 例如，要搜索測試，測試或測試員，我們可以使用搜索：

test*

我們還可以在術(shù)語中間使用通配符搜索。

te*t

這是Lucene通配符搜索的示例，

假設(shè)我們在“文件”目錄中有兩個文件。

test-foods.txt

以下是Deron喜歡的一些食物：

hamburger
french fries
steak mushrooms artichokes

sample-food.txt

以下是妮可喜歡的一些食物：

apples
bananas
salad mushrooms cheese

現(xiàn)在，我們看一下LuceneWildcardQueryDemo類。 此類基于上述文本文件通過createIndex()方法創(chuàng)建索引，此后，它嘗試對該索引執(zhí)行8個通配符搜索。 使用WildcardQuery類執(zhí)行其中四個搜索，而使用QueryParser類執(zhí)行其他四個搜索。

首先使用createIndex()方法對以上兩個文件建立索引。

public static void createIndex() throws CorruptIndexException, LockObtainFailedException, IOException {Analyzer analyzer = new StandardAnalyzer();boolean recreateIndexIfExists = true;IndexWriter indexWriter = new IndexWriter(INDEX_DIRECTORY, analyzer, recreateIndexIfExists);File dir = new File(FILES_TO_INDEX_DIRECTORY);File[] files = dir.listFiles();for (File file : files) {Document document = new Document();String path = file.getCanonicalPath();document.add(new Field(FIELD_PATH, path, Field.Store.YES, Field.Index.UN_TOKENIZED));Reader reader = new FileReader(file);document.add(new Field(FIELD_CONTENTS, reader));indexWriter.addDocument(document);}indexWriter.optimize();indexWriter.close(); }

為了使用查詢解析器執(zhí)行搜索操作，我們可以添加一個名為searchIndexWithQueryParser()的方法，

public static void searchIndexWithQueryParser(String whichField, String searchString) throws IOException,ParseException {System.out.println("\\nSearching for '" + searchString + "' using QueryParser");Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY);IndexSearcher indexSearcher = new IndexSearcher(directory);QueryParser queryParser = new QueryParser(whichField, new StandardAnalyzer());Query query = queryParser.parse(searchString);System.out.println("Type of query: " + query.getClass().getSimpleName());Hits hits = indexSearcher.search(query);displayHits(hits); }

使用以下代碼在searchIndexWithWildcardQuery()方法中執(zhí)行WildcardQuery查詢：

Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY); IndexSearcher indexSearcher = new IndexSearcher(directory); Term term = new Term(whichField, searchString); Query query = new WildcardQuery(term); Hits hits = indexSearcher.search(query);

QueryParser查詢通過以下方式在searchIndexWithQueryParser()方法中執(zhí)行：

Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY); IndexSearcher indexSearcher = new IndexSearcher(directory); QueryParser queryParser = new QueryParser(whichField, new StandardAnalyzer()); Query query = queryParser.parse(searchString); Hits hits = indexSearcher.search(query);

從我們的main（）方法可以看到， LuceneWildcardQueryDemo類執(zhí)行八個通配符搜索：

searchIndexWithWildcardQuery(FIELD_CONTENTS, "t*t"); searchIndexWithQueryParser(FIELD_CONTENTS, "t*t"); searchIndexWithWildcardQuery(FIELD_CONTENTS, "sam*"); searchIndexWithQueryParser(FIELD_CONTENTS, "sam*"); searchIndexWithWildcardQuery(FIELD_CONTENTS, "te?t"); searchIndexWithQueryParser(FIELD_CONTENTS, "te?t"); searchIndexWithWildcardQuery(FIELD_CONTENTS, "*est"); try { searchIndexWithQueryParser(FIELD_CONTENTS, "*est"); } catch (ParseException pe) { pe.printStackTrace(); }

最后，我們將使用類似的方法打印每次搜索操作的命中數(shù)，

public static void displayHits(Hits hits) throws CorruptIndexException, IOException {System.out.println("Number of hits: " + hits.length());Iterator<Hit> it = hits.iterator();while (it.hasNext()) {Hit hit = it.next();Document document = hit.getDocument();String path = document.get(FIELD_PATH);System.out.println("Hit: " + path);} }

如果我們運(yùn)行上面的代碼，它將向我們顯示，

Searching for 't*t' using WildcardQuery Number of hits: 1 Hit: /home/debarshi/workspace/Test/filesToIndex/test-foods.txtSearching for 't*t' using QueryParser Type of query: WildcardQuery Number of hits: 1 Hit: /home/debarshi/workspace/Test/filesToIndex/test-foods.txtSearching for 'sam*' using WildcardQuery Number of hits: 1 Hit: /home/debarshi/workspace/Test/filesToIndex/sample-foods.txtSearching for 'sam*' using QueryParser Type of query: PrefixQuery Number of hits: 1 Hit: /home/debarshi/workspace/Test/filesToIndex/sample-foods.txtSearching for 'te?t' using WildcardQuery Number of hits: 1 Hit: /home/debarshi/workspace/Test/filesToIndex/test-foods.txtSearching for 'te?t' using QueryParser Type of query: WildcardQuery Number of hits: 1 Hit: /home/debarshi/workspace/Test/filesToIndex/test-foods.txtSearching for '*est' using WildcardQuery Number of hits: 1 Hit: /home/debarshi/workspace/Test/filesToIndex/test-foods.txtSearching for '*est' using QueryParserorg.apache.lucene.queryParser.ParseException: Cannot parse '*est': '*' or '?' not allowed as first character in WildcardQuery at org.apache.lucene.queryParser.QueryParser.parse(QueryParser.java:175) at LuceneWildcardQueryDemo.searchIndexWithQueryParser(LuceneWildcardQueryDemo.java:81) at LuceneWildcardQueryDemo.main(LuceneWildcardQueryDemo.java:46)

第一個查詢使用帶有“ t * t”的WildcardQuery對象。 由于“ t * t”與索引中的“ test”匹配，因此此查詢返回1次匹配。

第二個查詢使用QueryParser查詢“ t * t”。 QueryParser parse()方法返回WildcardQuery ，并且該查詢返回1個匹配項(xiàng)，因?yàn)樗c第一個查詢基本相同。

第三個查詢使用帶有“ sam *”的WildcardQuery對象。 由于“ sam *”與“ sample”匹配，因此該通配符查詢獲得了成功。

第四個查詢使用帶有“ sam *”的QueryParser 。 但是請注意，QueryParser的parse()方法返回PrefixQuery而不是WildcardQuery 。 由于星號在“ sam *”的末尾。 由于“ sam *”與“ sample”匹配，因此該針對“ sam *”的PrefixQuery命中。

第五個查詢是WildcardQuery ，它在其搜索詞“ te？t”中使用問號。 問號可以匹配一個字符。 由于“ te？t”與“ test”匹配，因此搜索返回1個匹配項(xiàng)。

第六個查詢使用帶有“ te？t”的QueryParser 。 QueryParser parse()方法返回WildcardQuery ，并且與第五個查詢一樣，該命中率WildcardQuery 。

第七個查詢是“ * est”的WildcardQuery查詢。 由于“ test”匹配“ * est”，因此它收到一個匹配。 通常，在第一個字符為通配符的情況下執(zhí)行查詢不是一個好主意。

第八個查詢是“ * est”的QueryParser查詢。 請注意， QueryParser對象甚至不允許我們執(zhí)行第一個字符為星號的查詢。 引發(fā)解析異常。

4.3。布爾運(yùn)算符

布爾運(yùn)算符允許通過邏輯運(yùn)算符組合術(shù)語。 Lucene支持AND，“ +”，OR，NOT和“-”作為布爾運(yùn)算符（注意：布爾運(yùn)算符必須為ALL CAPS）。

OR運(yùn)算符是默認(rèn)的合取運(yùn)算符。 這意味著如果兩個術(shù)語之間沒有布爾運(yùn)算符，則使用OR運(yùn)算符。 OR運(yùn)算符鏈接兩個術(shù)語，如果文檔中存在兩個術(shù)語中的任何一個，則查找匹配的文檔。 這等效于使用集合的并集。 符號|| 可以代替單詞OR。

要搜索包含“ jakarta apache”或僅包含“ jakarta”的文檔，請使用查詢：

"jakarta apache" jakarta

要么

"jakarta apache" OR jakarta

和

AND運(yùn)算符匹配兩個術(shù)語都存在于單個文檔的文本中任意位置的文檔。 這等效于使用集合的交點(diǎn)。 可以使用符號&&代替單詞AND。

要搜索包含“ jakarta apache”和“ Apache Lucene”的文檔，請使用查詢：

"jakarta apache" AND "Apache Lucene"

+

“ +”或必需的運(yùn)算符要求“ +”符號后的術(shù)語存在于單個文檔的字段中。

要搜索必須包含“ jakarta”且可能包含“ lucene”的文檔，請使用以下查詢：

+jakarta lucene

不

NOT運(yùn)算符排除包含NOT之后的術(shù)語的文檔。 這等效于使用集的區(qū)別。 符號！ 可以代替“非”一詞使用。

要搜索包含“ jakarta apache”但不包含“ Apache Lucene”的文檔，請使用以下查詢：

"jakarta apache" NOT "Apache Lucene"

注意：NOT運(yùn)算符不能僅使用一個術(shù)語。 例如，以下搜索將不返回任何結(jié)果：

NOT "jakarta apache"

“-”

“-”或禁止運(yùn)算符排除包含在“-”符號后的術(shù)語的文檔。

要搜索包含“ jakarta apache”但不包含“ Apache Lucene”的文檔，請使用以下查詢：

"jakarta apache" -"Apache Lucene"

4.3分組

Lucene支持使用括號將子句分組以形成子查詢。 如果要控制查詢的布爾邏輯，這可能非常有用。

要搜索“ jakarta”或“ apache”和“網(wǎng)站”，請使用查詢：

(jakarta OR apache) AND website

這樣可以消除任何混亂，并確保您必須存在該網(wǎng)站，并且可能存在“雅加達(dá)”或“ apache”一詞。

現(xiàn)場分組

Lucene支持使用括號將多個子句分組到一個字段中。

要搜索包含單詞“ return”和短語“ pink panther”的標(biāo)題，請使用以下查詢：

title:(+return +"pink panther")

轉(zhuǎn)義特殊字符

Lucene支持轉(zhuǎn)義查詢語法中包含的特殊字符。 當(dāng)前列表的特殊字符為：

+ – && || ！ （）{} [] ^”?*嗎？ ：\

要轉(zhuǎn)義這些字符，請?jiān)谧址笆褂谩?\”（反斜杠）。 例如，要搜索（1 + 1）：2，請使用查詢：

\\(1\\+1\\)\\:2

4.4。短語查詢

Lucene中的PhraseQuery匹配包含特定術(shù)語序列的文檔。 PhraseQuery使用存儲在索引中的術(shù)語的位置信息。

查詢短語中單詞之間允許的其他單詞的數(shù)量稱為“斜率”。 可以通過調(diào)用setSlop方法進(jìn)行設(shè)置。 如果為零，則為精確短語搜索。 對于較大的值，其工作方式類似于WITHIN或NEAR運(yùn)算符。

斜率實(shí)際上是一個編輯距離，其中單位對應(yīng)于查詢短語中詞條移動的位置。 例如，要切換兩個單詞的順序需要兩個步驟（第一個步驟將單詞彼此放在首位），因此要允許對短語進(jìn)行重新排序，斜率必須至少為兩個。

較精確的匹配比不精確的匹配得分更高，因此搜索結(jié)果按精確性排序。 默認(rèn)情況下，斜率為零，要求完全匹配。

PhraseQuery還支持多個術(shù)語短語。

短語查詢可以與其他術(shù)語組合，也可以與BooleanQuery組合使用。 默認(rèn)情況下，子句的最大數(shù)量限制為1,024。

在前面的Lucene通配符查詢示例中，我們已經(jīng)基于兩個文本文件完成了搜索操作。 現(xiàn)在，我們將嘗試在Lucene中使用PhraseQuery查找匹配的短語。

為此，我們將引入一個新方法searchIndexWithPhraseQuery()代替searchIndexWithWildcardQuery()方法，該方法采用兩個字符串表示文檔中的單詞和一個傾斜值。 它通過基于“ contents”字段以及string1和string2參數(shù)添加兩個Term對象來構(gòu)造PhraseQuery 。 然后，它使用setSlop()方法設(shè)置PhraseQuery對象的setSlop()值。 通過將PhraseQuery對象傳遞給IndexSearcher的search()方法來進(jìn)行search() 。 這是代碼，

public static void searchIndexWithPhraseQuery(String string1, String string2, int slop) throws IOException,ParseException {Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY);IndexSearcher indexSearcher = new IndexSearcher(directory);Term term1 = new Term(FIELD_CONTENTS, string1);Term term2 = new Term(FIELD_CONTENTS, string2);PhraseQuery phraseQuery = new PhraseQuery();phraseQuery.add(term1);phraseQuery.add(term2);phraseQuery.setSlop(slop);displayQuery(phraseQuery);Hits hits = indexSearcher.search(phraseQuery);displayHits(hits); }

而且，我們從main()調(diào)用此方法，

searchIndexWithPhraseQuery("french", "fries", 0);searchIndexWithPhraseQuery("hamburger", "steak", 0);searchIndexWithPhraseQuery("hamburger", "steak", 1);searchIndexWithPhraseQuery("hamburger", "steak", 2);searchIndexWithPhraseQuery("hamburger", "steak", 3);searchIndexWithQueryParser("french fries"); // BooleanQuerysearchIndexWithQueryParser("\\"french fries\\""); // PhaseQuerysearchIndexWithQueryParser("\\"hamburger steak\\"~1"); // PhaseQuerysearchIndexWithQueryParser("\\"hamburger steak\\"~2"); // PhaseQuery

第一個查詢以斜率0搜索“ french”和“ fries”，這意味著短語搜索最終是對“ french fries”的搜索，其中“ french”和“ fries”彼此相鄰。 由于這存在于test-foods.txt中，因此我們獲得了1次點(diǎn)擊。

在第二個查詢中，我們搜索坡度為0的“漢堡”和“牛排”。由于在兩個文檔中都不存在“漢堡”和“牛排”，因此得到0個匹配。 第三個查詢還涉及對“漢堡包”和“牛排”的搜索，但斜率為1。這些單詞彼此之間的距離不超過1個單詞，因此我們獲得0次匹配。

第四個查詢以“ 2”的斜率搜索“漢堡”和“牛排”。在test-foods.txt文件中，我們有“……漢堡薯?xiàng)l……”字樣。 由于“漢堡”和“牛排”彼此之間不超過兩個字，因此我們獲得1分。 第五個短語查詢是相同的搜索，但斜率為3。由于“漢堡包”和“牛排”彼此帶有三個單詞（彼此是兩個單詞），因此命中率為1。

接下來的四個查詢使用QueryParser 。 注意，在第一個QueryParser查詢中，我們得到一個BooleanQuery而不是PhraseQuery 。 這是因?yàn)槲覀儌鬟f了QueryParser的parse()方法“炸薯?xiàng)l”而不是“ \”炸薯?xiàng)l\””。 如果我們希望QueryParser生成PhraseQuery，則搜索字符串需要用雙引號引起來。 下一個查詢確實(shí)會搜索“ \”炸薯?xiàng)l\”，并且我們可以看到它生成了一個PhraseQuery （默認(rèn)PhraseQuery為0），并響應(yīng)該查詢獲得了1次PhraseQuery 。

最后兩個QueryParser查詢演示了設(shè)置傾斜值。 我們可以看到，可以在搜索字符串的雙引號后面設(shè)置斜率值，并在其后加上斜線號（?）和斜率號。

4.5。范圍查詢

與專有術(shù)語范圍內(nèi)的文檔匹配的Query 。 它允許匹配字段值在RangeQuery指定的上下限之間的RangeQuery 。 范圍查詢可以包含上限或下限，也可以不包括上限和下限。 排序是按字典順序進(jìn)行的（按字典順序排列（排序）的項(xiàng)的集合）。

現(xiàn)在，如果要為Lucene搜索操作實(shí)現(xiàn)RangeQuery ，則必須添加一個名為searchIndexWithRangeQuery() ，該方法基本上是一個構(gòu)造函數(shù)，需要一個Term指示范圍的開始，一個Term指示范圍的結(jié)束和一個布爾值，指示搜索是包含開始和結(jié)束值（“ true”）還是排除開始和結(jié)束值（“ false”）。 代碼看起來像

public static void searchIndexWithRangeQuery(String whichField, String start, String end, boolean inclusive)throws IOException, ParseException {System.out.println("\\nSearching for range '" + start + " to " + end + "' using RangeQuery");Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY);IndexSearcher indexSearcher = new IndexSearcher(directory);Term startTerm = new Term(whichField, start);Term endTerm = new Term(whichField, end);Query query = new RangeQuery(startTerm, endTerm, inclusive);Hits hits = indexSearcher.search(query);displayHits(hits); }

現(xiàn)在我們將調(diào)用上述方法，

searchIndexWithRangeQuery(FIELD_LAST_MODIFIED, "2014-04-01-00-00-00", "2014-04-01-23-59-59", INCLUSIVE);searchIndexWithRangeQuery(FIELD_LAST_MODIFIED, "2014-04-02-00-00-00", "2014-04-02-23-59-59", INCLUSIVE);searchIndexWithRangeQuery(FIELD_LAST_MODIFIED, "2014-04-01-00-00-00", "2014-04-01-21-21-02", INCLUSIVE);searchIndexWithRangeQuery(FIELD_LAST_MODIFIED, "2014-04-01-00-00-00", "2014-04-01-21-21-02", EXCLUSIVE);// equivalent range searches using QueryParsersearchIndexWithQueryParser(FIELD_LAST_MODIFIED, "[2014-04-01-00-00-00 TO 2014-04-01-23-59-59]");searchIndexWithQueryParser(FIELD_LAST_MODIFIED, "[2014-04-02-00-00-00 TO 2014-04-02-23-59-59]");searchIndexWithQueryParser(FIELD_LAST_MODIFIED, "[2014-04-01-00-00-00 TO 2014-04-01-21-21-02]");searchIndexWithQueryParser(FIELD_LAST_MODIFIED, "{2014-04-01-00-00-00 TO 2014-04-01-21-21-02}");

最后， createIndex()方法稍有變化。 我們添加了一些實(shí)現(xiàn)日期時間的操作并打印了索引文件的最后修改時間。

在控制臺輸出的頂部，我們可以看到兩個文件都已建立索引，并且這些文件的“最后修改”時間為“ 2014-04-01-21-21-02”（對于test-foods.txt ）和“ 2014-04-01-21-21-38”（針對sample-foods.txt）。

在第一個范圍查詢中，我們搜索所有在2014年4月1日最后一次修改的文件。由于兩個文件在該日期最后一次修改，這將返回2次匹配。 在第二個范圍查詢中，我們搜索所有在2014年4月2日最后一次修改的文件。由于兩個文檔都在2014年4月1日最后一次修改，因此返回0次匹配。

接下來，我們在2014年4月1日至2014年4月1日至2014年4月1日的范圍內(nèi)進(jìn)行搜索。 由于test-foods.txt的上次修改時間為2014-04-01-21-21-02，并且范圍查詢包含此值，因此我們獲得了一個搜索結(jié)果。 之后，我們僅在2014-04-01-00-00-00到2014-04-01-21-21-02之間進(jìn)行搜索。 由于test-foods.txt的上次修改時間為2014-04-01-21-21-02，并且范圍查詢不包含此值（因?yàn)橐褜⑵渑懦谕?#xff09;，因此此搜索返回0個匹配。

此后，接下來的四個搜索顯示使用QueryParser對象執(zhí)行的等效搜索。 請注意，對于每個查詢，QueryParser的parse()方法都返回ConstantScoreRangeQuery對象而不是RangeQuery對象，正如我們從這些查詢的控制臺輸出中看到的那樣。

4.6。前綴查詢

與包含帶有指定前綴的術(shù)語的文檔匹配的Query 。 PrefixQuery由QueryParser構(gòu)建，用于類似nam *的輸入。

我們將嘗試使用兩個文本文件（test-foods.txt和sample-foods.txt）通過前綴查詢來搜索帶有其前綴的特定術(shù)語。

對于這樣做，我們將增加一個名為方法searchIndexWithPrefixQuery()將搜索器的索引（這將創(chuàng)建createIndex()使用PrefixQuery 。 此方法有兩個參數(shù)，一個是字段名，另一個是搜索字符串。

public static void searchIndexWithPrefixQuery(String whichField, String searchString) throws IOException,ParseException {System.out.println("\\nSearching for '" + searchString + "' using PrefixQuery");Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY);IndexSearcher indexSearcher = new IndexSearcher(directory);Term term = new Term(whichField, searchString);Query query = new PrefixQuery(term);Hits hits = indexSearcher.search(query);displayHits(hits); }

接下來，我們將從程序的main()方法中調(diào)用此方法–

searchIndexWithPrefixQuery(FIELD_CONTENTS, "test");searchIndexWithPrefixQuery(FIELD_CONTENTS, "tes*");

在第一個查詢中，查詢字符串不包含星號。 因此，如果我們打印QueryParser的parse()方法的查詢類型，它將打印TermQuery而不是PrefixQuery 。

在第二查詢中，星號向QueryParser指示這是一個前綴查詢，因此它從其parse()方法返回PrefixQuery對象。 這導(dǎo)致在索引內(nèi)容中搜索前綴“ tes”。 由于“ test”在索引中，因此產(chǎn)生1次匹配。

4.7。模糊查詢

模糊查詢基于Damerau-Levenshtein（最佳字符串對齊）算法。 FuzzyQuery將術(shù)語“接近”匹配到指定的基本術(shù)語：我們指定了一個允許的最大編輯距離，并且在與基本術(shù)語（然后包含這些術(shù)語的文檔）相距該編輯距離內(nèi)的所有術(shù)語都匹配。

QueryParser語法是QueryParser或QueryParser ，其中N是允許的最大編輯數(shù)量（對于較早的發(fā)行版，N是0.0到1.0之間的令人困惑的浮點(diǎn)數(shù)，它通過一個棘手的公式轉(zhuǎn)換為等效的最大編輯距離）。

FuzzyQuery非常適合匹配專有名稱：我們可以搜索lucene?1，它將匹配luccene（插入c），lucee（刪除n），lukene（用k替換c）和許多其他“接近”術(shù)語。 使用最大編輯距離2，我們最多可以有2個插入，刪除或替換。 每次比賽的得分均基于該詞的編輯距離； 因此完全匹配的得分最高； 編輯距離1，降低； 等等

QueryParser支持在詞條上使用尾隨波浪號的模糊詞條查詢。 例如，搜索wuzza?將找到包含“ fuzzy”和“ wuzzy”的文檔。 編輯距離會影響得分，例如，較低的編輯距離會得分較高。

翻譯自: https://www.javacodegeeks.com/2015/09/advanced-lucene-query-examples.html

總結(jié)

以上是生活随笔為你收集整理的高级Lucene查询示例的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。