{"id":44590,"date":"2015-09-27T22:08:28","date_gmt":"2015-09-27T19:08:28","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=44590"},"modified":"2023-12-06T15:42:41","modified_gmt":"2023-12-06T13:42:41","slug":"advanced-lucene-query-examples","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html","title":{"rendered":"Advanced Lucene Query Examples"},"content":{"rendered":"

This article is part of our Academy Course titled Apache Lucene Fundamentals<\/a>.<\/p>\n

In this course, you will get an introduction to Lucene. You will see why a library like this is important and then learn how searching works in Lucene. Moreover, you will learn how to integrate Lucene Search into your own applications in order to provide robust searching capabilities. Check it out here<\/a>!<\/em><\/p>\n

\n

Table Of Contents<\/h4>\n
\n
1.Introduction<\/a><\/dt>\n
2.Lucene Queries<\/a><\/dt>\n
3.Lucene Query API<\/a><\/dt>\n
4.Basic search<\/a><\/dt>\n
\n
\n
4.1.Terms<\/a><\/dt>\n
4.2.WildcardQuery<\/a><\/dt>\n
4.3.Boolean Operators<\/a><\/dt>\n
4.3.Grouping<\/a><\/dt>\n
4.4.PhraseQuery<\/a><\/dt>\n
4.5.RangeQuery<\/a><\/dt>\n
4.6.Prefix Query<\/a><\/dt>\n
4.7.Fuzzy Query<\/a><\/dt>\n<\/dl>\n<\/dd>\n<\/dl>\n<\/div>\n

<\/a>1.Introduction<\/h2>\n

In a previous chapter we have learned the different components of the Lucene search engine<\/a>. We also have built up a small search application using lucene indexing & searching procedures. In this chapter we will talk about the Lucene queries.<\/p>\n

<\/a>2.Lucene Queries<\/h2>\n

Lucene has a custom query syntax for querying its indexes. A query is broken up into terms and operators. Terms are of two types: 1.Single Terms<\/strong> and 2.Phrases<\/strong>. A Single Term is a single word such as “test” or “sample”. A Phrase is a group of words surrounded by double quotes such as “welcome lucene”. Multiple terms can be combined together with Boolean operators to form a more complex query. With Lucene Java, TermQuery is the most primitive Query. Then there\u2019s BooleanQuery, PhraseQuery, and many other Query subclasses to choose from.<\/p>\n

Fields<\/strong> When performing a search we can specify the field you want to search in. Any existing field name can be used as field name. The syntax is, FieldName:VALUE<\/em>. There are a few special field types that have their own syntax for defining the query term. For example DateTime: ModificationDate:>’2010-09-01 12:00:00′ We will explain searching operations on these fields in a later section.<\/p>\n

<\/a>3.Lucene Query API<\/h2>\n

When a human-readable query is parsed by Lucene’s QueryParser<\/code>, it is converted to a single concrete subclass of the Query class. We need some understanding of the underlying concrete Query subclasses. The relevant subclasses, their purpose, and some example expressions for each are listed in the following table:<\/p>\n\n\n\n\n\n\n\n\n\n\n
Query Implementation<\/strong><\/th>\nPurpose<\/strong><\/th>\nSample expressions<\/strong><\/th>\n<\/tr>\n
TermQuery<\/code><\/td>\nSingle term query, which effectively is a single word.<\/td>\nreynolds<\/td>\n<\/tr>\n
PhraseQuery<\/code><\/td>\nA match of several terms in order, or in near vicinity to one another.<\/td>\n“light up ahead”<\/td>\n<\/tr>\n
RangeQuery<\/code><\/td>\nMatches documents with terms between beginning and ending terms, including or excluding the end points.<\/td>\n[A TO Z]<\/p>\n

{A TO Z}<\/td>\n<\/tr>\n

WildcardQuery<\/code><\/td>\nLightweight, regular-expression-like term-matching syntax.<\/td>\nj*v?<\/p>\n

f??bar<\/td>\n<\/tr>\n

PrefixQuery<\/code><\/td>\nMatches all terms that begin with a specified string.<\/td>\ncheese*<\/td>\n<\/tr>\n
FuzzyQuery<\/code><\/td>\nLevenshtein algorithm for closeness matching.<\/td>\ntree~<\/td>\n<\/tr>\n
BooleanQuery<\/code><\/td>\nAggregates other Query instances into complex expressions allowing AND, OR, and NOT logic.<\/td>\nreynolds AND “light up ahead”<\/p>\n

cheese* -cheesewhiz<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 
\nAll of these Query<\/code> implementations are in the org.apache.lucene.search<\/code> package. The BooleanQuery<\/code> is a bit of a special case because it is a Query<\/code> container that aggregates other queries (including nested BooleanQuery<\/code>s for sophisticated expressions).<\/p>\n

Here is a BooleanQuery<\/code> based on the query snippet. Here we can see how the QueryParser-created query is equivalent to the API-created one:<\/p>\n

\npublic class RulezTest extends TestCase { \n  public void testJavaNotDotNet() throws Exception { \n    BooleanQuery apiQuery = new BooleanQuery(); \n    apiQuery.add(new TermQuery(new Term(\"contents\", \"java\")), true, false); \n    apiQuery.add(new TermQuery(new Term(\"contents\", \"net\")), true, false); \n    apiQuery.add(new TermQuery(new Term(\"contents\", \"dot\")), false, true); \n    Query qpQuery = QueryParser.parse(\"java AND net NOT dot\", \"contents\", new StandardAnalyzer()); \n    \/\/ Query and subclasses behave as expected with .equals \n    assertEquals(qpQuery, apiQuery); \n  } \n}\n<\/pre>\n
Some interesting features of the Query<\/code> classes are their toString<\/code> methods. Each Query<\/code> subclass generates the equivalent (though not necessarily textually exact) QueryParserexpression<\/code>. There are two variants: one is the standard Object.toString<\/code> overridden method, and the other accepts the default field name. The following test case demonstrates how these two methods work, and illustrates how an equivalent (yet not the exact) expression is returned.<\/p>\n
\npublic void testToString() throws Exception { \n  Query query = QueryParser.parse(\"java AND net NOT dot\", \"contents\", new StandardAnalyzer()); \n  assertEquals(\"+java +net -dot\", query.toString(\"contents\")); \n  assertEquals(\"+contents:java +contents:net -contents:dot\", query.toString()); \n}\n<\/pre>\n
Notice that the expression parsed was ‘java AND net NOT dot’, but the expression returned from the toString<\/code> methods used the abbreviated syntax ‘+java +net -dot’. Our first test case (testJavaNotDotNet<\/code>) demonstrated that the underlying query objects themselves are equivalent.<\/p>\n
The no-arg toString<\/code> method makes no assumptions about the field names for each term, and specifies them explicitly using field-selector syntax. Using these toString<\/code> methods is handy for diagnosing QueryParser<\/code> issues.<\/p>\n
<\/a>4.Basic search<\/h2>\n
In most cases you want to look for a single term or a phrase, which is a group of words surrounded by double quotes (“sample application”). In these cases we will look for contents that has these words in their default index data that contains all the relevant text of the content.<\/p>\n
In more complex situations we may need some filtering based on the type or place of the content we are looking for, or we want to search in a specific field. Here we can learn how to construct more complex queries that can be used to effectively find content in a huge repository.<\/p>\n
<\/a>4.1.Terms<\/h3>\n
Suppose we want to search with a keyword ‘blog’ in the tag field. The syntax will be,<\/p>\n
tag :  blog<\/pre>\n
Now we will search with a phrase ‘lucene blog’ in the tag field. For that the syntax will be,<\/p>\n
tag :   \"lucene blog\"<\/pre>\n
Now lets search ‘lucene blog’ in the tag field, and ‘technical blog’ in the body,<\/p>\n
tag : \"lucene blog\" AND body : \"technical blog\"<\/pre>\n
Suppose we want to search for phrase ‘lucene blog’ in the tag field, and ‘technical blog’ in the body or ‘searching blog’ phrase in tag field,<\/p>\n
(tag : \"lucene blog\" AND body : \"technical blog\") OR tag : \"searching blog\"<\/pre>\n
If we want to search ‘blog’ not ‘lucene’ in the tag field, the syntax will look alike,<\/p>\n
tag : blog -tag : lucene<\/pre>\n
<\/a>4.2.WildcardQuery<\/h3>\n
Lucene supports single and multiple character wildcard searches within single terms (not within phrase queries).<\/p>\n
    \n
  1. To perform a single character wildcard search use the “?” symbol.<\/li>\n
  2. To perform a multiple character wildcard search use the “*” symbol.<\/li>\n<\/ol>\n
    The single character wildcard search looks for terms that match that with the single character replaced. For example, to search for “text” or “test” we can use the search: te?t<\/p>\n
    Multiple character wildcard searches looks for 0 or more characters. For example, to search for test, tests or tester, we can use the search:<\/p>\n
    test*<\/pre>\n
    We can also use the wildcard searches in the middle of a term.<\/p>\n
    te*t<\/pre>\n
    Here is an example of lucene wildcard search,<\/p>\n
    Suppose, we have two files in the ‘files’ directory.<\/p>\n
      \n
    1. test-foods.txt\n
      Here are some foods that Deron likes:<\/p>\n
      hamburger<\/code>
      \nfrench fries<\/code>
      \nsteak<\/code>
      \nmushrooms<\/code>
      \nartichokes<\/code>\n<\/li>\n
    2. sample-food.txt\n
      Here are some foods that Nicole likes:<\/p>\n
      apples<\/code>
      \nbananas<\/code>
      \nsalad<\/code>
      \nmushrooms<\/code>
      \ncheese<\/code><\/li>\n<\/ol>\n
      Now we’ll look at the LuceneWildcardQueryDemo<\/code> class. This class creates an index via the createIndex()<\/code> method based on the text files mentioned above, and after this, it attempts to perform 8 wildcard searches against this index. Four of the searches are performed using the WildcardQuery<\/code> class, and the other four searches are performed using the QueryParser<\/code> class.
       
      <\/div> <\/div><\/p>\n
      The above 2 files are indexed first using a createIndex()<\/code> method.<\/p>\n
      \npublic static void createIndex() throws CorruptIndexException, LockObtainFailedException, IOException {\n  Analyzer analyzer = new StandardAnalyzer();\n  boolean recreateIndexIfExists = true;\n  IndexWriter indexWriter = new IndexWriter(INDEX_DIRECTORY, analyzer, recreateIndexIfExists);\n  File dir = new File(FILES_TO_INDEX_DIRECTORY);\n  File[] files = dir.listFiles();\n  for (File file : files) {\n    Document document = new Document();\n    String path = file.getCanonicalPath();\n    document.add(new Field(FIELD_PATH, path, Field.Store.YES, Field.Index.UN_TOKENIZED));\n    Reader reader = new FileReader(file);\n    document.add(new Field(FIELD_CONTENTS, reader));\n    indexWriter.addDocument(document);\n  }\n  indexWriter.optimize();\n  indexWriter.close();\n}\n<\/pre>\n
      For doing the searching operations using the query parser, we can add a method named searchIndexWithQueryParser()<\/code>,<\/p>\n
      \npublic static void searchIndexWithQueryParser(String whichField, String searchString) throws IOException,ParseException {\n  System.out.println(\"\\\\nSearching for '\" + searchString + \"' using QueryParser\");\n  Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY);\n  IndexSearcher indexSearcher = new IndexSearcher(directory);\n  QueryParser queryParser = new QueryParser(whichField, new StandardAnalyzer());\n  Query query = queryParser.parse(searchString);\n  System.out.println(\"Type of query: \" + query.getClass().getSimpleName());\n  Hits hits = indexSearcher.search(query);\n  displayHits(hits);\n}\n<\/pre>\n
      The WildcardQuery<\/code> queries are performed in the searchIndexWithWildcardQuery()<\/code> method, using the following code:<\/p>\n
      \n  Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY); \n  IndexSearcher indexSearcher = new IndexSearcher(directory); \n  Term term = new Term(whichField, searchString); \n  Query query = new WildcardQuery(term); \n  Hits hits = indexSearcher.search(query);\n<\/pre>\n
      The QueryParser<\/code> queries are performed in the searchIndexWithQueryParser()<\/code> method via:<\/p>\n
      \n  Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY); \n  IndexSearcher indexSearcher = new IndexSearcher(directory); \n  QueryParser queryParser = new QueryParser(whichField, new StandardAnalyzer()); \n  Query query = queryParser.parse(searchString); \n  Hits hits = indexSearcher.search(query);\n<\/pre>\n
      The LuceneWildcardQueryDemo<\/code> class performs eight wildcard searches, as we can see from its main() method:<\/p>\n
      \n  searchIndexWithWildcardQuery(FIELD_CONTENTS, \"t*t\"); \n  searchIndexWithQueryParser(FIELD_CONTENTS, \"t*t\"); \n  searchIndexWithWildcardQuery(FIELD_CONTENTS, \"sam*\"); \n  searchIndexWithQueryParser(FIELD_CONTENTS, \"sam*\"); \n  searchIndexWithWildcardQuery(FIELD_CONTENTS, \"te?t\"); \n  searchIndexWithQueryParser(FIELD_CONTENTS, \"te?t\"); \n  searchIndexWithWildcardQuery(FIELD_CONTENTS, \"*est\"); \n  try { \n    searchIndexWithQueryParser(FIELD_CONTENTS, \"*est\"); \n  } catch (ParseException pe) { \n    pe.printStackTrace(); \n  }\n<\/pre>\n
      Lastly we will print the number of hits for each searching operations using a method like,<\/p>\n
      \npublic static void displayHits(Hits hits) throws CorruptIndexException, IOException {\n  System.out.println(\"Number of hits: \" + hits.length());\n  Iterator<Hit> it = hits.iterator();\n  while (it.hasNext()) {\n    Hit hit = it.next();\n    Document document = hit.getDocument();\n    String path = document.get(FIELD_PATH);\n    System.out.println(\"Hit: \" + path);\n  }\n}\n<\/pre>\n
      If we run the above code, it will show us,<\/p>\n
      Searching for 't*t' using WildcardQuery\nNumber of hits: 1\nHit: \/home\/debarshi\/workspace\/Test\/filesToIndex\/test-foods.txt<\/pre>\n
      Searching for 't*t' using QueryParser\nType of query: WildcardQuery\nNumber of hits: 1\nHit: \/home\/debarshi\/workspace\/Test\/filesToIndex\/test-foods.txt<\/pre>\n
      Searching for 'sam*' using WildcardQuery\nNumber of hits: 1\nHit: \/home\/debarshi\/workspace\/Test\/filesToIndex\/sample-foods.txt<\/pre>\n
      Searching for 'sam*' using QueryParser\nType of query: PrefixQuery\nNumber of hits: 1\nHit: \/home\/debarshi\/workspace\/Test\/filesToIndex\/sample-foods.txt<\/pre>\n
      Searching for 'te?t' using WildcardQuery\nNumber of hits: 1\nHit: \/home\/debarshi\/workspace\/Test\/filesToIndex\/test-foods.txt<\/pre>\n
      Searching for 'te?t' using QueryParser\nType of query: WildcardQuery\nNumber of hits: 1\nHit: \/home\/debarshi\/workspace\/Test\/filesToIndex\/test-foods.txt<\/pre>\n
      Searching for '*est' using WildcardQuery\nNumber of hits: 1\nHit: \/home\/debarshi\/workspace\/Test\/filesToIndex\/test-foods.txt<\/pre>\n
      Searching for '*est' using QueryParser\n\n  org.apache.lucene.queryParser.ParseException: Cannot parse '*est': '*' or '?' not allowed as first character in WildcardQuery \n  at org.apache.lucene.queryParser.QueryParser.parse(QueryParser.java:175) \n  at LuceneWildcardQueryDemo.searchIndexWithQueryParser(LuceneWildcardQueryDemo.java:81) \n  at LuceneWildcardQueryDemo.main(LuceneWildcardQueryDemo.java:46)\n<\/pre>\n
        \n
      1. The first query uses a WildcardQuery<\/code> object with “t*t”. Since “t*t” matches “test” in the index, this query returns 1 hit.<\/li>\n
      2. The second query uses a QueryParser<\/code> to query “t*t”. The QueryParser parse()<\/code> method returns a WildcardQuery<\/code>, and the query returns 1 hit, since it’s basically identical to the first query.<\/li>\n
      3. The third query uses a WildcardQuery<\/code> object with “sam*”. This wildcard query gets one hit, since “sam*” matches “sample”.<\/li>\n
      4. The fourth query uses QueryParser<\/code> with “sam*”. Notice, however, that QueryParser’s parse()<\/code> method returns a PrefixQuery<\/code> rather than a WildcardQuery<\/code>. Since the asterisk is at the end of “sam*”. This PrefixQuery<\/code> for “sam*” gets a hit, since “sam*” matches “sample”.<\/li>\n
      5. The fifth query is a WildcardQuery<\/code> that utilizes a question mark in its search word, “te?t”. The question mark can match one character. Since “te?t” matches “test”, the search returns 1 hit.<\/li>\n
      6. The sixth query uses a QueryParser<\/code> with “te?t”. The QueryParser parse()<\/code> method returns a WildcardQuery<\/code>, and it gets on hit, just like the fifth query.<\/li>\n
      7. The seventh query is a WildcardQuery<\/code> for “*est”. It receives one match, since “test” matches “*est”. In general, it’s not a good idea to perform queries where the first character is a wildcard.<\/li>\n
      8. The eigth query is a QueryParser<\/code> query for “*est”. Notice that the QueryParser<\/code> object does not even allow us to perform a query where the first character is an asterisk. It throws a parse exception.<\/li>\n<\/ol>\n
        <\/a>4.3.Boolean Operators<\/h3>\n
        Boolean operators allow terms to be combined through logic operators. Lucene supports AND, “+”, OR, NOT and “-” as Boolean operators (Note: Boolean operators must be ALL CAPS).<\/p>\n
        The OR operator is the default conjunction operator. This means that if there is no Boolean operator between two terms, the OR operator is used. The OR operator links two terms and finds a matching document if either of the terms exist in a document. This is equivalent to a union using sets. The symbol || can be used in place of the word OR.<\/p>\n
        To search for documents that contain either “jakarta apache” or just “jakarta” use the query:<\/p>\n
        \"jakarta apache\" jakarta <\/pre>\n
        or<\/strong><\/p>\n
        \"jakarta apache\" OR jakarta<\/pre>\n
        AND<\/strong><\/p>\n
        The AND operator matches documents where both terms exist anywhere in the text of a single document. This is equivalent to an intersection using sets. The symbol && can be used in place of the word AND.<\/p>\n
        To search for documents that contain “jakarta apache” and “Apache Lucene” use the query:<\/p>\n
        \"jakarta apache\" AND \"Apache Lucene\" <\/pre>\n
        +<\/strong><\/p>\n
        The “+” or required operator requires that the term after the “+” symbol exist somewhere in a the field of a single document.<\/p>\n
        To search for documents that must contain “jakarta” and may contain “lucene” use the query:<\/p>\n
        +jakarta lucene <\/pre>\n
        NOT<\/strong><\/p>\n
        The NOT operator excludes documents that contain the term after NOT. This is equivalent to a difference using sets. The symbol ! can be used in place of the word NOT.<\/p>\n
        To search for documents that contain “jakarta apache” but not “Apache Lucene” use the query:<\/p>\n
        \"jakarta apache\" NOT \"Apache Lucene\" <\/pre>\n
        Note: The NOT operator cannot be used with just one term. For example, the following search will return no results:<\/p>\n
        NOT \"jakarta apache\" <\/pre>\n
         \u201c-\u201d<\/strong><\/p>\n
        The “-” or prohibit operator excludes documents that contain the term after the “-” symbol.<\/p>\n
        To search for documents that contain “jakarta apache” but not “Apache Lucene” use the query:<\/p>\n
        \"jakarta apache\" -\"Apache Lucene\" <\/pre>\n
        <\/a>4.3.Grouping<\/h3>\n
        Lucene supports using parentheses to group clauses to form sub queries. This can be very useful if you want to control the boolean logic for a query.<\/p>\n
        To search for either “jakarta” or “apache” and “website” use the query:<\/p>\n
        (jakarta OR apache) AND website <\/pre>\n
        This eliminates any confusion and makes sure you that website must exist and either term jakarta or apache may exist.<\/p>\n
        Field Grouping<\/b><\/p>\n
        Lucene supports using parentheses to group multiple clauses to a single field.<\/p>\n
        To search for a title that contains both the word “return” and the phrase “pink panther” use the query:<\/p>\n
        title:(+return +\"pink panther\") <\/pre>\n
        Escaping Special Characters<\/b><\/p>\n
        Lucene supports escaping special characters that are part of the query syntax. The current list special characters are:<\/p>\n
        + – && || ! ( ) { } [ ] ^ ” ~ * ? : \\<\/p>\n
        To escape these character use “\\” (backslash) before the character. For example to search for (1+1):2 use the query:<\/p>\n
        \\\\(1\\\\+1\\\\)\\\\:2 <\/pre>\n
        <\/a>4.4.PhraseQuery<\/h3>\n
        A PhraseQuery<\/code> in Lucene matches documents containing a particular sequence of terms. PhraseQuery<\/code> uses positional information of the term that is stored in an index.<\/p>\n
        The number of other words permitted between words in query phrase is called “slop”. It can be set by calling the setSlop method. If zero, then this is an exact phrase search. For larger values this works like a WITHIN or NEAR operator.<\/p>\n
        The slop is in fact an edit-distance, where the units correspond to moves of terms in the query phrase out of position. For example, to switch the order of two words requires two moves (the first move places the words atop one another), so to permit re-orderings of phrases, the slop must be at least two.<\/p>\n
        More exact matches are scored higher than sloppier matches, thus search results are sorted by exactness. The slop is zero by default, requiring exact matches.<\/p>\n
        PhraseQuery<\/code> also supports multiple term phrases.<\/p>\n
        A Phrase Query may be combined with other terms or queries with a BooleanQuery<\/code>. The maximum number of clauses is restricted to 1,024 by default.<\/p>\n
        In the previous example of lucene wildcard query, we have done the searching operations based on two text files. Now we will try to find matching phrases using PhraseQuery in lucene.<\/p>\n
        For that, instead of searchIndexWithWildcardQuery()<\/code> method, we will introduce a new method searchIndexWithPhraseQuery()<\/code> which takes two strings representing words in the document and a slop value. It constructs a PhraseQuery<\/code> by adding two Term objects based on the “contents” field and the string1 and string2 parameters. Following that, it sets the slop value of the PhraseQuery<\/code> object using the setSlop()<\/code> method of PhraseQuery. The search is conducted by passing the PhraseQuery<\/code> object to IndexSearcher’s search()<\/code> method. Here is the code,<\/p>\n
        \npublic static void searchIndexWithPhraseQuery(String string1, String string2, int slop) throws IOException,ParseException {\n  Directory directory = \tFSDirectory.getDirectory(INDEX_DIRECTORY);\n  IndexSearcher indexSearcher = new IndexSearcher(directory);\n  Term term1 = new Term(FIELD_CONTENTS, string1);\n  Term term2 = new Term(FIELD_CONTENTS, string2);\n  PhraseQuery phraseQuery = new PhraseQuery();\n  phraseQuery.add(term1);\n  phraseQuery.add(term2);\n  phraseQuery.setSlop(slop);\n  displayQuery(phraseQuery);\n  Hits hits = indexSearcher.search(phraseQuery);\n  displayHits(hits);\n}\n<\/pre>\n
        And, we call this method from main()<\/code>,<\/p>\n
        \n  searchIndexWithPhraseQuery(\"french\", \"fries\", 0);\n  searchIndexWithPhraseQuery(\"hamburger\", \"steak\", 0);\n  searchIndexWithPhraseQuery(\"hamburger\", \"steak\", 1);\n  searchIndexWithPhraseQuery(\"hamburger\", \"steak\", 2);\n  searchIndexWithPhraseQuery(\"hamburger\", \"steak\", 3);\n  searchIndexWithQueryParser(\"french fries\"); \/\/ BooleanQuery\n  searchIndexWithQueryParser(\"\\\\\"french fries\\\\\"\"); \/\/ PhaseQuery\n  searchIndexWithQueryParser(\"\\\\\"hamburger steak\\\\\"~1\"); \/\/ PhaseQuery\n  searchIndexWithQueryParser(\"\\\\\"hamburger steak\\\\\"~2\"); \/\/ PhaseQuery\n<\/pre>\n
        The first query searches for “french” and “fries” with a slop of 0, meaning that the phrase search ends up being a search for “french fries”, where “french” and “fries” are next to each other. Since this exists in test-foods.txt, we get 1 hit.<\/p>\n
        In the second query, we search for “hamburger” and “steak” with a slop of 0. Since “hamburger” and “steak” don’t exist next to each other in either document, we get 0 hits. The third query also involves a search for “hamburger” and “steak”, but with a slop of 1. These words are not within 1 word of each other, so we get 0 hits.<\/p>\n
        The fourth query searches for “hamburger” and “steak” with a slop of 2. In the test-foods.txt file, we have the words “… hamburger french fries steak …”. Since “hamburger” and “steak” are within two words of each other, we get 1 hit. The fifth phrase query is the same search but with a slop of 3. Since “hamburger” and “steak” are withing three words of each other (they are two words from each other), we get a hit of 1.<\/p>\n
        The next four queries utilize QueryParser<\/code>. Notice that in the first of the QueryParser<\/code> queries, we get a BooleanQuery<\/code> rather than a PhraseQuery<\/code>. This is because we passed QueryParser’s parse()<\/code> method “french fries” rather than “\\”french fries\\””. If we want QueryParser to generate a PhraseQuery, the search string needs to be surrounded by double quotes. The next query does search for “\\”french fries\\”” and we can see that it generates a PhraseQuery<\/code> (with the default slop of 0) and gets 1 hit in response to the query.<\/p>\n
        The last two QueryParser<\/code> queries demonstrate setting slop values. We can see that the slop values can be set the following the double quotes of the search string with a tilde (~) following by the slop number.<\/p>\n
        <\/a>4.5.RangeQuery<\/h3>\n
        A Query<\/code> that matches documents within an exclusive range of terms. It allows one to match documents whose field(s) values are between the lower and upper bound specified by the RangeQuery<\/code>. Range Queries can be inclusive or exclusive of the upper and lower bounds. Sorting is done lexicographically(a collection of items arranged(sorted) in the dictionary order).<\/p>\n
        Now, if we want to implement RangeQuery<\/code> for Lucene searching operations, we have to add a method named like, searchIndexWithRangeQuery()<\/code>, which is basically a constructor which requires a Term<\/code> indicating the start of the range, a Term<\/code> indicating the end of the range, and a boolean value indicating whether the search is inclusive of the start and end values (“true”) or exclusive of the start and end values (“false”). The code looks like,<\/p>\n
        \npublic static void searchIndexWithRangeQuery(String whichField, String start, String end, boolean inclusive)\n  throws IOException, ParseException {\n  System.out.println(\"\\\\nSearching for range '\" + start + \" to \" + end + \"' using RangeQuery\");\n  Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY);\n  IndexSearcher indexSearcher = new IndexSearcher(directory);\n  Term startTerm = new Term(whichField, start);\n  Term endTerm = new Term(whichField, end);\n  Query query = new RangeQuery(startTerm, endTerm, inclusive);\n  Hits hits = indexSearcher.search(query);\n  displayHits(hits);\n}\n<\/pre>\n
        Now we will call the above method,<\/p>\n
        \n  searchIndexWithRangeQuery(FIELD_LAST_MODIFIED, \"2014-04-01-00-00-00\", \"2014-04-01-23-59-59\", INCLUSIVE);\n  searchIndexWithRangeQuery(FIELD_LAST_MODIFIED, \"2014-04-02-00-00-00\", \"2014-04-02-23-59-59\", INCLUSIVE);\n  searchIndexWithRangeQuery(FIELD_LAST_MODIFIED, \"2014-04-01-00-00-00\", \"2014-04-01-21-21-02\", INCLUSIVE);\n  searchIndexWithRangeQuery(FIELD_LAST_MODIFIED, \"2014-04-01-00-00-00\", \"2014-04-01-21-21-02\", EXCLUSIVE);\n  \/\/ equivalent range searches using QueryParser\n  searchIndexWithQueryParser(FIELD_LAST_MODIFIED, \"[2014-04-01-00-00-00 TO 2014-04-01-23-59-59]\");\n  searchIndexWithQueryParser(FIELD_LAST_MODIFIED, \"[2014-04-02-00-00-00 TO 2014-04-02-23-59-59]\");\n  searchIndexWithQueryParser(FIELD_LAST_MODIFIED, \"[2014-04-01-00-00-00 TO 2014-04-01-21-21-02]\");\n  searchIndexWithQueryParser(FIELD_LAST_MODIFIED, \"{2014-04-01-00-00-00 TO 2014-04-01-21-21-02}\");\n<\/pre>\n
        Lastly, there is a little change in createIndex()<\/code> method. We have added some date time realted operations & printed the last modified time of the indexing files.<\/p>\n
        At the top of the console output, we can see that the two files get indexed, and that the “last modified” times for these files are “2014-04-01-21-21-02” (for test-foods.txt) and “2014-04-01-21-21-38” (for sample-foods.txt).<\/p>\n
        In the first range query, we search for all files that were last modified on April 1st 2014. This returns 2 hits since both files were last modified on this date. In the second range query, we search for all files that were last modified on April 2nd 2014. This returns 0 hits, since both documents were last modified on April 1st 2014.<\/p>\n
        Next, we search in a range from 2014-04-01-00-00-00 to 2014-04-01-21-21-02, inclusively. Since test-foods.txt was last modified at 2014-04-01-21-21-02 and the range query includes this value, we get one search hit. Following this, we search in a range from 2014-04-01-00-00-00 to 2014-04-01-21-21-02, exclusively. Since test-foods.txt was last modified at 2014-04-01-21-21-02 and the range query doesn’t include this value (since it is excluded), this search returns 0 hits.<\/p>\n
        After this, our next four searches show the equivalent searches performed using a QueryParser<\/code> object. Notice that QueryParser’s parse()<\/code> method returns a ConstantScoreRangeQuery<\/code> object rather than a RangeQuery<\/code> object for each of these queries, as we can see from the console output for these queries.<\/p>\n
        <\/a>4.6.Prefix Query<\/h3>\n
        A Query<\/code> that matches documents containing terms with a specified prefix. A PrefixQuery<\/code> is built by QueryParser<\/code> for input like nam*.<\/p>\n
        We will try to search certain term with its prefix using the prefix query using the two text files (test-foods.txt & sample-foods.txt).<\/p>\n
        For doing that we will add a method named searchIndexWithPrefixQuery()<\/code> which will searche the index (which will be created by createIndex()<\/code>) using a PrefixQuery<\/code>. This method takes two parameters, one is the field name & another is the search string.<\/p>\n
        \npublic static void searchIndexWithPrefixQuery(String whichField, String searchString) throws IOException,\n  ParseException {\n  System.out.println(\"\\\\nSearching for '\" + searchString + \"' using PrefixQuery\");\n  Directory directory = FSDirectory.getDirectory(INDEX_DIRECTORY);\n  IndexSearcher indexSearcher = new IndexSearcher(directory);\n  Term term = new Term(whichField, searchString);\n  Query query = new PrefixQuery(term);\n  Hits hits = indexSearcher.search(query);\n  displayHits(hits);\n}\n<\/pre>\n
        Next we will call this method from main()<\/code> method of program –<\/p>\n
        \n  searchIndexWithPrefixQuery(FIELD_CONTENTS, \"test\");\n  searchIndexWithPrefixQuery(FIELD_CONTENTS, \"tes*\");\n<\/pre>\n
        In the first query, the query string does not contain an asterisk. So if we print the query type of QueryParser’s parse()<\/code> method, it will print TermQuery<\/code> instead of PrefixQuery<\/code>.<\/p>\n
        In the secong query the asterisk indicates to the QueryParser<\/code> that this is a prefix query, so it returns a PrefixQuery<\/code> object from its parse()<\/code> method. This results in a search for the prefix “tes” in the indexed contents. This results in 1 hit, since “test” is in the index.<\/p>\n
        <\/a>4.7.Fuzzy Query<\/h3>\n
        Fuzzy query is based on Damerau-Levenshtein (optimal string alignment) algorithm. FuzzyQuery<\/code> matches terms “close” to a specified base term: we specify an allowed maximum edit distance, and any terms within that edit distance from the base term (and, then, the docs containing those terms) are matched.<\/p>\n
        The QueryParser<\/code> syntax is term~ or term~N, where N is the maximum allowed number of edits (for older releases N was a confusing float between 0.0 and 1.0, which translates to an equivalent max edit distance through a tricky formula).<\/p>\n
        FuzzyQuery<\/code> is great for matching proper names: we can search for lucene~1 and it will match luccene (insert c), lucee (remove n), lukene(replace c with k) and a great many other “close” terms. With max edit distance 2 we can have up to 2 insertions, deletions or substitutions. The score for each match is based on the edit distance of that term; so an exact match is scored highest; edit distance 1, lower; etc.<\/p>\n
        QueryParser<\/code> supports fuzzy-term queries using a trailing tilde on a term. For example, searching for wuzza~ will find documents that contain “fuzzy” and “wuzzy”. Edit distance affects scoring, such that lower edit distances score higher.<\/p>\n","protected":false},"excerpt":{"rendered":"
        This article is part of our Academy Course titled Apache Lucene Fundamentals. In this course, you will get an introduction to Lucene. You will see why a library like this is important and then learn how searching works in Lucene. Moreover, you will learn how to integrate Lucene Search into your own applications in order …<\/p>\n","protected":false},"author":448,"featured_media":71,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[26],"class_list":["post-44590","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-enterprise-java","tag-apache-lucene"],"yoast_head":"\nAdvanced Lucene Query Examples - Java Code Geeks<\/title>\n<meta name=\"description\" content=\"This article is part of our Academy Course titled Apache Lucene Fundamentals. In this course, you will get an introduction to Lucene. You will see why a\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Advanced Lucene Query Examples - Java Code Geeks\" \/>\n<meta property=\"og:description\" content=\"This article is part of our Academy Course titled Apache Lucene Fundamentals. In this course, you will get an introduction to Lucene. You will see why a\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html\" \/>\n<meta property=\"og:site_name\" content=\"Java Code Geeks\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/javacodegeeks\" \/>\n<meta property=\"article:author\" content=\"http:\/\/www.facebook.com\/phlocblogger\" \/>\n<meta property=\"article:published_time\" content=\"2015-09-27T19:08:28+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-12-06T13:42:41+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/apache-lucene-logo.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"150\" \/>\n\t<meta property=\"og:image:height\" content=\"150\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Piyas De\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@https:\/\/twitter.com\/phloxblog\" \/>\n<meta name=\"twitter:site\" content=\"@javacodegeeks\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Piyas De\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"14 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html\"},\"author\":{\"name\":\"Piyas De\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/person\\\/20f3c9ff4b90d43da03decd2ad2b4f37\"},\"headline\":\"Advanced Lucene Query Examples\",\"datePublished\":\"2015-09-27T19:08:28+00:00\",\"dateModified\":\"2023-12-06T13:42:41+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html\"},\"wordCount\":3079,\"commentCount\":1,\"publisher\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/apache-lucene-logo.jpg\",\"keywords\":[\"Apache Lucene\"],\"articleSection\":[\"Enterprise Java\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html\",\"name\":\"Advanced Lucene Query Examples - Java Code Geeks\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/apache-lucene-logo.jpg\",\"datePublished\":\"2015-09-27T19:08:28+00:00\",\"dateModified\":\"2023-12-06T13:42:41+00:00\",\"description\":\"This article is part of our Academy Course titled Apache Lucene Fundamentals. In this course, you will get an introduction to Lucene. You will see why a\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html#primaryimage\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/apache-lucene-logo.jpg\",\"contentUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/apache-lucene-logo.jpg\",\"width\":150,\"height\":150},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/advanced-lucene-query-examples.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Java\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/category\\\/java\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Enterprise Java\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/category\\\/java\\\/enterprise-java\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Advanced Lucene Query Examples\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#website\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\",\"name\":\"Java Code Geeks\",\"description\":\"Java Developers Resource Center\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\"},\"alternateName\":\"JCG\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.javacodegeeks.com\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\",\"name\":\"Exelixis Media P.C.\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/exelixis-logo.png\",\"contentUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/exelixis-logo.png\",\"width\":864,\"height\":246,\"caption\":\"Exelixis Media P.C.\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/javacodegeeks\",\"https:\\\/\\\/x.com\\\/javacodegeeks\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/person\\\/20f3c9ff4b90d43da03decd2ad2b4f37\",\"name\":\"Piyas De\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/eadd6728b7b5be23f0d6585da1a953926e49c6f2369703d6cb4f1147d4dd2203?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/eadd6728b7b5be23f0d6585da1a953926e49c6f2369703d6cb4f1147d4dd2203?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/eadd6728b7b5be23f0d6585da1a953926e49c6f2369703d6cb4f1147d4dd2203?s=96&d=mm&r=g\",\"caption\":\"Piyas De\"},\"description\":\"Piyas is Sun Microsystems certified Enterprise Architect with 10+ years of professional IT experience in various areas such as Architecture Definition, Define Enterprise Application, Client-server\\\/e-business solutions.Currently he is engaged in providing solutions for digital asset management in media companies.He is also founder and main author of \\\"Technical Blogs(Blog about small technical Know hows)\\\" Hyperlink - http:\\\/\\\/www.phloxblog.in\",\"sameAs\":[\"http:\\\/\\\/www.phloxblog.in\",\"http:\\\/\\\/www.facebook.com\\\/phlocblogger\",\"http:\\\/\\\/in.linkedin.com\\\/in\\\/piyasde\",\"https:\\\/\\\/x.com\\\/https:\\\/\\\/twitter.com\\\/phloxblog\"],\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/author\\\/piyas-de\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Advanced Lucene Query Examples - Java Code Geeks","description":"This article is part of our Academy Course titled Apache Lucene Fundamentals. In this course, you will get an introduction to Lucene. You will see why a","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html","og_locale":"en_US","og_type":"article","og_title":"Advanced Lucene Query Examples - Java Code Geeks","og_description":"This article is part of our Academy Course titled Apache Lucene Fundamentals. In this course, you will get an introduction to Lucene. You will see why a","og_url":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html","og_site_name":"Java Code Geeks","article_publisher":"https:\/\/www.facebook.com\/javacodegeeks","article_author":"http:\/\/www.facebook.com\/phlocblogger","article_published_time":"2015-09-27T19:08:28+00:00","article_modified_time":"2023-12-06T13:42:41+00:00","og_image":[{"width":150,"height":150,"url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/apache-lucene-logo.jpg","type":"image\/jpeg"}],"author":"Piyas De","twitter_card":"summary_large_image","twitter_creator":"@https:\/\/twitter.com\/phloxblog","twitter_site":"@javacodegeeks","twitter_misc":{"Written by":"Piyas De","Est. reading time":"14 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html#article","isPartOf":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html"},"author":{"name":"Piyas De","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/person\/20f3c9ff4b90d43da03decd2ad2b4f37"},"headline":"Advanced Lucene Query Examples","datePublished":"2015-09-27T19:08:28+00:00","dateModified":"2023-12-06T13:42:41+00:00","mainEntityOfPage":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html"},"wordCount":3079,"commentCount":1,"publisher":{"@id":"https:\/\/www.javacodegeeks.com\/#organization"},"image":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html#primaryimage"},"thumbnailUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/apache-lucene-logo.jpg","keywords":["Apache Lucene"],"articleSection":["Enterprise Java"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html","url":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html","name":"Advanced Lucene Query Examples - Java Code Geeks","isPartOf":{"@id":"https:\/\/www.javacodegeeks.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html#primaryimage"},"image":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html#primaryimage"},"thumbnailUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/apache-lucene-logo.jpg","datePublished":"2015-09-27T19:08:28+00:00","dateModified":"2023-12-06T13:42:41+00:00","description":"This article is part of our Academy Course titled Apache Lucene Fundamentals. In this course, you will get an introduction to Lucene. You will see why a","breadcrumb":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html#primaryimage","url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/apache-lucene-logo.jpg","contentUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/apache-lucene-logo.jpg","width":150,"height":150},{"@type":"BreadcrumbList","@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/advanced-lucene-query-examples.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.javacodegeeks.com\/"},{"@type":"ListItem","position":2,"name":"Java","item":"https:\/\/www.javacodegeeks.com\/category\/java"},{"@type":"ListItem","position":3,"name":"Enterprise Java","item":"https:\/\/www.javacodegeeks.com\/category\/java\/enterprise-java"},{"@type":"ListItem","position":4,"name":"Advanced Lucene Query Examples"}]},{"@type":"WebSite","@id":"https:\/\/www.javacodegeeks.com\/#website","url":"https:\/\/www.javacodegeeks.com\/","name":"Java Code Geeks","description":"Java Developers Resource Center","publisher":{"@id":"https:\/\/www.javacodegeeks.com\/#organization"},"alternateName":"JCG","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.javacodegeeks.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.javacodegeeks.com\/#organization","name":"Exelixis Media P.C.","url":"https:\/\/www.javacodegeeks.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/logo\/image\/","url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2022\/06\/exelixis-logo.png","contentUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2022\/06\/exelixis-logo.png","width":864,"height":246,"caption":"Exelixis Media P.C."},"image":{"@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/javacodegeeks","https:\/\/x.com\/javacodegeeks"]},{"@type":"Person","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/person\/20f3c9ff4b90d43da03decd2ad2b4f37","name":"Piyas De","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/eadd6728b7b5be23f0d6585da1a953926e49c6f2369703d6cb4f1147d4dd2203?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/eadd6728b7b5be23f0d6585da1a953926e49c6f2369703d6cb4f1147d4dd2203?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/eadd6728b7b5be23f0d6585da1a953926e49c6f2369703d6cb4f1147d4dd2203?s=96&d=mm&r=g","caption":"Piyas De"},"description":"Piyas is Sun Microsystems certified Enterprise Architect with 10+ years of professional IT experience in various areas such as Architecture Definition, Define Enterprise Application, Client-server\/e-business solutions.Currently he is engaged in providing solutions for digital asset management in media companies.He is also founder and main author of \"Technical Blogs(Blog about small technical Know hows)\" Hyperlink - http:\/\/www.phloxblog.in","sameAs":["http:\/\/www.phloxblog.in","http:\/\/www.facebook.com\/phlocblogger","http:\/\/in.linkedin.com\/in\/piyasde","https:\/\/x.com\/https:\/\/twitter.com\/phloxblog"],"url":"https:\/\/www.javacodegeeks.com\/author\/piyas-de"}]}},"_links":{"self":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts\/44590","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/users\/448"}],"replies":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/comments?post=44590"}],"version-history":[{"count":0,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts\/44590\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/media\/71"}],"wp:attachment":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/media?parent=44590"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/categories?post=44590"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/tags?post=44590"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}