Fuzzy Search - WalnUtil - Simple Lucene Tutorial by Sample

Inegrated Search Engine - ISE
Tool for DBA, Database Developers, Sofware Developers, Business Analysts

Home | WalnUtil for SQL Server | WalnUtil for Oracle | WalnUtil Feedback |

Few words about examples located below for Lucene( .NET and Java). In our opinion, the most useful training grants, those are which contain clear and simple examples of use for corresponding software. Our examples contain all necessary comments in a code. We have tried to capture these examples the most useful possibilities Lucene. Examples allow to see on how many is convenient and various Lucene for creation different type of searchers.Compare how is working Lucene.net and Lucene Java.

How to use Tutorial/Example see in the code below:

Questions...? Feedback...

Simple Lucene Tutorial by Sample - Java

  
/// file MainRun.java
public class MainRun {
public static  void main(String[] args) throws Exception {
// run test
AnalyzerRunTest analyzerRunTest = new AnalyzerRunTest();
analyzerRunTest.runQueryTest();
}

}
//////////////////
/// file AnalyzerRunTest.java
        /* WalnUtilSoft.com:  Very Simple Lucene Tutorial by Sample -Java */
///Simple Test Run Java Lucene Tutorial
/// Used 3 fields:1.f1-id-<pkID> unuque -not analyze ;2. f2-<description1>;
/// f3 - <description2>
/// Using different type Analyzers and corresponded parameters:
/// Field.Store; Field.Index
/// For using code download and install next software:
/// 1. Java latest version jre 6; jdk1.6: http://www.java.com/en/download/manual.jsp
/// 2. Lucene 2.9.3 : http://lucene.apache.org/java/docs/
/// 3. Eclepce : eclipse-java-ganymede-SR2-win32.zip:http://www.eclipse.org/downloads/packages/release/ganymede/sr2
 
import java.io.IOException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.SimpleAnalyzer;
import org.apache.lucene.analysis.KeywordAnalyzer;
import org.apache.lucene.analysis.PerFieldAnalyzerWrapper;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.FuzzyQuery;

import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;

import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.TopScoreDocCollector;
import org.apache.lucene.search.BooleanClause.Occur;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.util.Version;


public class AnalyzerRunTest {
		private IndexSearcher indexSearcher;
		
		public void runQueryTest() throws Exception {
		    Directory directory = new RAMDirectory(); 
		    
		    int inputField0V = 1;//first value for id
		    float sim = 0.5f; // Similarity , range 0...1
		    // values for f2 and f3
		    String inputField1V = "walnutil used for Developers,DBA,Business Analists";
		    String inputField2V = "walnutil";
		    // search string in f2 and/or f3
		    String inputField1Vs = "walnutil used";// for Developers,DBA,Business Analists";
		  
		    // field's names
		    String  inputField0 = "pkID";
		    String  inputField1 = "description1";
		    String  inputField2 = "description2";		 
		  
		   // multi-field analyzer/indexes 
		   // here we can add/change any analyzer for testing 
		    PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(
		            new StandardAnalyzer(Version.LUCENE_29));    
		    analyzer.addAnalyzer(inputField1,new StandardAnalyzer(Version.LUCENE_29)); // new KeywordAnalyzer());   
		    analyzer.addAnalyzer(inputField2, new KeywordAnalyzer()); 
		      
		    System.out.println("Added Analyzer = "  + analyzer.toString());
		   
		    IndexWriter writer = new IndexWriter(directory,
		    		analyzer, 
		            IndexWriter.MaxFieldLength.UNLIMITED);   
		    

		    Document doc = new Document();
		    // test: 2 records added:		    
		    // f1 not analyzed can be stored or not
		    // f2 and f2 analyzed and stored
		    
		    // first record
		    doc.add(new Field(inputField0,
		    				Integer.toString(inputField0V),
		                      Field.Store.YES,
		                      Field.Index.NOT_ANALYZED_NO_NORMS));   //only id 
		    doc.add(new Field(inputField1,
		    					inputField1V,
		                      Field.Store.YES,
		                      Field.Index.ANALYZED)); 
		    doc.add(new Field(inputField2,
					inputField2V,
		          Field.Store.YES,
		          Field.Index.ANALYZED)); 
		    writer.addDocument(doc);
		    // second record
		    doc.add(new Field(inputField0,
					Integer.toString(inputField0V+1),
		              Field.Store.NO,
		              Field.Index.NOT_ANALYZED_NO_NORMS));   //A
		doc.add(new Field(inputField1,
						inputField1V,
		              Field.Store.YES,
		              Field.Index.ANALYZED));
		doc.add(new Field(inputField2,
			inputField2V,
		  Field.Store.YES,
		  Field.Index.ANALYZED));
		writer.addDocument(doc);

		    System.out.println(writer.numDocs() + " docs in index");
		    writer.optimize();
		    writer.close();
	/// Finish to create indexes
		    
    // Start to search string - inputField1Vs in f2 and f3 fields
		    // set/define fields, occur
		    IndexReader reader = IndexReader.open(directory,true);//true:readOnly - true if no changes (deletions, norms) will be made with this IndexReader   
		    int fieldSize = reader.document(0).getFields().size();
		    String[] field = new String[fieldSize] ;//
		    BooleanClause.Occur[] flags = new BooleanClause.Occur[fieldSize] ;
		    // set Occur for corresponded fields
		    for(int i = 0; i < fieldSize; i++){
		    	field[i] = ((Field) reader.document(0).getFields().get(i)).name();//
		    	flags[i] = BooleanClause.Occur.SHOULD;//..MUST;
		    }
		    // eliminate empty char, comma or something else from searched string
		    // or use as is
		    // Split input string 
		    String qur0 = inputField1Vs.replace(","," ");
		    qur0 = qur0.replace(" *"," ");
		    String[] searchDataArray = qur0.split(" ");
		    String strSearchDataArray = "";
		    for (int i = 0; i < searchDataArray.length; i++)
		    {
		        strSearchDataArray = strSearchDataArray + searchDataArray[i].toString() + "~" + sim + " ";
		    }
		    inputField1Vs = inputField1Vs.toLowerCase();
		    
		 // search start:
		// search with term and MUST
		    String[] fNew1 =  {field[1]};
		    String fInput1 = inputField2;
		    System.out.println(" ");
		    System.out.println("\n-----------*******----------");
		    System.out.println(" search with term and MUST");
		    indexSearcher = new IndexSearcher(directory,true);
		    
		    BooleanQuery bq1 = new  BooleanQuery();
		    Term t1 = new Term(fInput1, inputField1Vs);
		    Query query1 = new TermQuery(t1);
		    bq1.add(query1, Occur.MUST);
		    System.out.println(" Query:  " + bq1);
		    TopDocs docs1 = indexSearcher.search(bq1, 10); 
		    System.out.println(" totalHits:  " + docs1.totalHits + "; MaxScore: " + docs1.getMaxScore());
		    
		    runQueryAndDisplayResults(fNew1,directory, bq1);//query1) ;
		    indexSearcher.close();
		////////////////////////////////////////////////////////////////////    
		    
		 // search with term and SHOULD
		    String[] fNew11 =  {field[1]};
		    String fInput11 = inputField2;
		    System.out.println(" ");
		    System.out.println("\n-----------*******----------");
		    System.out.println(" search with term and SHOULD");
		    indexSearcher = new IndexSearcher(directory,true);
		    BooleanQuery bq11 = new  BooleanQuery();
		    Term t11 = new Term(fInput11, inputField1Vs);
		    Query query11 = new TermQuery(t11);
		    bq11.add(query11, Occur.SHOULD);
		    System.out.println(" Query:  " + bq11);
		    TopDocs docs11 = indexSearcher.search(bq11, 10);   
		    System.out.println(" totalHits:  " + docs11.totalHits + "; MaxScore: " + docs11.getMaxScore());
		    runQueryAndDisplayResults(fNew11,directory, bq11);//query11) ;
		    indexSearcher.close();
		    //////////////////////////////////////////////////////////////////////
		    
		   // PhraseQuery Example
		    String[] fNew111 =  {field[1]};
		    String fInput111 = inputField2;
		    System.out.println(" ");
		    System.out.println("\n-----------*******----------");
		    System.out.println(" search with PhraseQuery ");
		    
		    indexSearcher = new IndexSearcher(directory,true);
		    PhraseQuery pq = new  PhraseQuery();  
		    Term t111 = new Term(fInput111, inputField1Vs);    
		    pq.add(t111 );
		    Query query111 = new TermQuery(t11);
		    System.out.println(" Term Query compare with PhraseQuery:  " + query111 );
		    System.out.println(" Query:  " + pq);//
		    TopDocs docs111 = indexSearcher.search(pq, 10); 
		    System.out.println(" totalHits:  " + docs111.totalHits + "; MaxScore: " + docs111.getMaxScore());
		    runQueryAndDisplayResults(fNew111,directory, pq) ;
		    indexSearcher.close();
		    //////////////////////////////////////////////////////////////////
		    // search with parse and MUST
		    String[] fNew12 =  {field[1]};
		    String fInput12 = inputField2;
		    System.out.println(" ");
		    System.out.println("\n-----------*******----------");
		    System.out.println(" search with parse and MUST and SHOULD ");
		    indexSearcher = new IndexSearcher(directory,true);
		    BooleanQuery bq12 = new  BooleanQuery();
		    
		    QueryParser queryParser12 = new QueryParser(Version.LUCENE_29, fInput12,
		    				analyzer);
		    Query query12  = queryParser12.parse(inputField1Vs);
		  
		    bq12.add(query12, Occur.MUST);
		    System.out.println(" Query: MUST: " + query12);
		    TopDocs docs12 = indexSearcher.search(query12, 10); 
		    System.out.println(" totalHits:  " + docs12.totalHits + "; MaxScore: " + docs12.getMaxScore());
		    runQueryAndDisplayResults(fNew12,directory, query12) ;
		    
		    BooleanQuery bq13 = new  BooleanQuery();
		    bq13.add(query12, Occur.SHOULD);
		    System.out.println(" Query: SHOULD " + query12);
		    TopDocs docs13 = indexSearcher.search(query12, 10); 
		    System.out.println(" totalHits:  " + docs13.totalHits + "; MaxScore: " + docs13.getMaxScore());
		    runQueryAndDisplayResults(fNew12,directory, query12) ;
		    indexSearcher.close(); 
		  ///////////////////////////////////////////////////  
		 // PhraseQuery Example
		   
		    String[] fNew121 =  {field[0]};
		    String fInput121 = inputField1;
		    System.out.println(" ");
		    System.out.println("\n-----------*******----------");
		    System.out.println(" search with PhraseQuery  ");
		    indexSearcher = new IndexSearcher(directory,true);
		      
		    PhraseQuery pq121 = new  PhraseQuery();  
		    Term t121 = new Term(fInput121, inputField1Vs);
		    
		    pq121.add(t121 );
		    System.out.println(" Query: PhraseQuery " + pq121);
		    
		    TopDocs docs121 = indexSearcher.search(pq121, 10);
		    System.out.println(" totalHits:  " + docs121.totalHits + "; MaxScore: " + docs121.getMaxScore());
		    runQueryAndDisplayResults(fNew121,directory, pq121) ;
		    indexSearcher.close();
		    /////////////////////////////////////////////////////
		    // fuzzy search
		    System.out.println(" ");
		    System.out.println("\n-----------*******----------");
		    System.out.println(" search with FuzzyQuery and term  ");
		    indexSearcher = new IndexSearcher(directory,true);      
		    
		    Term t20 = new Term(fInput121, inputField1Vs);
		    Query  query20 = new FuzzyQuery(t20);
		    System.out.println(" Query: term for fuzzy " + query20);
		    TopDocs docs20 = indexSearcher.search(query20, 10); 
		    System.out.println(" totalHits:  " + docs20.totalHits + "; MaxScore: " + docs20.getMaxScore());
		  
		    runQueryAndDisplayResults(fNew121,directory, query20) ;
		    indexSearcher.close();
		    //////////////////////////////////////////////

		  //MultiFieldQueryParser for all fields 
		    System.out.println(" ");
		    System.out.println("\n-----------*******----------");
		    System.out.println(" search with MultiFieldQueryParser full text  ");
		    System.out.println(" ");
		    indexSearcher = new IndexSearcher(directory,true);
		    // MultiFieldQueryParser.parse static method
		   /* MultiFieldQueryParser mfqp = new MultiFieldQueryParser(Version.LUCENE_29,
		    		field,
		    		analyzer);*/
		   
		    Query queryMFQP = MultiFieldQueryParser.parse(Version.LUCENE_29,strSearchDataArray, field, flags, analyzer);
		    
		    System.out.println(" Query: term for full text, separated each word with simulariry " + queryMFQP);	
		  
		    TopDocs docs21 = indexSearcher.search(queryMFQP, 10); 
		    System.out.println(" totalHits:  " + docs21.totalHits + "; MaxScore: " + docs21.getMaxScore());
		    
		    runQueryAndDisplayResults(field,directory, queryMFQP) ;		    
		    
		  }

		  
		  public void 
			runQueryAndDisplayResults(String[] searchedField,Directory indexStore, Query q) 
			throws IOException {
			  int hitsPerPage = 10;	  
			
				IndexSearcher searcher = new IndexSearcher(indexStore,true);
				
				int fieldSize = searchedField.length;
			    String[] field = new String[fieldSize] ;//	   
			    System.out.println(" " );
			    for(int i = 0; i < fieldSize; i++){    	
			    	field[i] = searchedField[i];
			    	System.out.print((i + 1) + ".Field: "  + field[i] + " ; ");	
			    }	   
				TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerPage, true);
				searcher.search(q, collector);
				System.out.println(" Query :"  + q);
				ScoreDoc[] hits = collector.topDocs().scoreDocs;
				 
				int _length = hits.length;//
				System.out.println("HITS: " + _length);	
				for (int i = 0; i < _length; i++) {
					int docId = hits[i].doc;
					// detail info for score calculating 
					System.out.println("Explain : " + searcher.explain(q, docId).toString());
				    Document d = searcher.doc(docId);		   
				    String score = Float.toString(hits[i].score);// 
				    System.out.println((i + 1) + ". Score:"  + score);
				    for(int j = 0; j<fieldSize;j++){
				    	System.out.println(" Field: " +  field[j] + ":" + d.get(field[j]));
				    }				   	    
				}			
				searcher.close();
			}
	}

Simple Lucene Tutorial by Sample - C#

        // file Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LuceneNETRunTest
{
    class Program
    {
        static void Main(string[] args)
        {
            AnalyzerRunTest analyzerRunTest = new AnalyzerRunTest();
            analyzerRunTest.runQueryTest();
        }
    }
}
////////////////////////
/// file AnalyzerRunTest.cs
/// WalnUtilSoft.com: 
/// Simple Test Run .NET Lucene Tutorial by Example
/// Used 3 fields:1.f1-id-<pkID> unuque -not analyze ;2. f2-<description1>;
/// f3 - <description2>
/// Using different type Analyzers and corresponded parameters:
/// Field.Store; Field.Index
/// For using code download and install next software:
/// 1. C# Visual Studio 2005/2008 framework 2.0/3.5: http://www.microsoft.com
/// 2. Lucene.net_2_9_2 : https://svn.apache.org/repos/asf/lucene/lucene.net/tags/
/// for get Lucene_2_9_2 use SVN - 
/// 3. SVN - TortoiseSVN-1.6.7.18415-win32-svn-1.6.9.msi - http://tortoisesvn.net/downloads
/// just follow instrauctions for installing SVN, then compile Lucene_2_9_2 and use Lucene.Net.dll from ...\LuceneNet\Lucene.Net_2_9_2\src\Lucene.Net\bin\Release\

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Lucene.Net.Store;
using Lucene.Net.Analysis;
using Lucene.Net.Analysis.Standard;
using Lucene.Net.Index;
using Lucene.Net.Documents;
using Lucene.Net.Search;
using System.Reflection;
using System.Collections;
using Lucene.Net.QueryParsers;

namespace LuceneNETRunTest
{
    public class AnalyzerRunTest {
	

		private IndexSearcher indexSearcher;
        
	   
		public void runQueryTest()  {            
            Directory directory = new RAMDirectory();

            int inputField0V = 1;//first value for id
            float sim = 0.5f;//Similarity , range 0...1
            // values for f2 and f3
            String inputField1V = "walnutil used for Developers,DBA,Business Analists";//
		    String inputField2V = "walnutil";// used for Developers,DBA,Business Analists";
            // search string in f2 and/or f3
            String inputField1Vs = "walnutil used for Developers,DBA,Business Analists";//compatuble";//walnutil used for Developers,DBA,Business Analists";//search as one word - KeywordAnalyzer

            // field's names
            String  inputField0 = "pkID";
		    String  inputField1 = "description1";
		    String  inputField2 = "description2";

            // multi-field analyzer/indexes 
            // here we can add/change any analyzer for testing 
		    PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(
                    new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29));   
		    analyzer.AddAnalyzer(inputField1,new KeywordAnalyzer());  
            analyzer.AddAnalyzer(inputField2, new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29)); 
		      
            
		    Console.WriteLine("Added Analyzer = "  + analyzer.ToString());

            IndexWriter writer = new IndexWriter(directory,
                    analyzer,
                    IndexWriter.MaxFieldLength.UNLIMITED);
 
		    Document doc = new Document();
            // test: 2 records added:		    
            // f1 not analyzed can be stored or not
            // f2 and f2 analyzed and stored

            // first record
		    
		    doc.Add(new Field(inputField0,
		    				inputField0V.ToString(),
		                      Field.Store.NO,
		                      Field.Index.NOT_ANALYZED_NO_NORMS));   //only id 
		    doc.Add(new Field(inputField1,
		    					inputField1V,
		                      Field.Store.YES,
		                      Field.Index.ANALYZED));
		    doc.Add(new Field(inputField2,
					inputField2V,
		          Field.Store.YES,
		          Field.Index.ANALYZED)); 
		    writer.AddDocument(doc);
		    // second record
		    doc.Add(new Field(inputField0,
					(inputField0V+1).ToString(),
		              Field.Store.NO,
		              Field.Index.NOT_ANALYZED_NO_NORMS));
		doc.Add(new Field(inputField1,
						inputField1V,
		              Field.Store.YES,
		              Field.Index.ANALYZED));
		doc.Add(new Field(inputField2,
			inputField2V,
		  Field.Store.YES,
		  Field.Index.ANALYZED));
		writer.AddDocument(doc);

		    Console.WriteLine(writer.DocCount() + " docs in index");//.NumDocs()
		    writer.Optimize();
		    writer.Close();
            /// Finish to create indexes

            // Start to search string - inputField1Vs in f2 and f3 fields
            // set/define fields, occur
		    IndexReader reader = IndexReader.Open(directory,true);            
            int fieldSize = reader.Document(0).GetFields().Count;		  
            String[] field = new String[fieldSize] ;//
		    BooleanClause.Occur[] flags = new BooleanClause.Occur[fieldSize] ;
            // set Occur for corresponded fields
            for(int i = 0; i < fieldSize; i++){
                field[i] = ((Field)reader.Document(0).GetFields()[i]).Name();
             	flags[i] = BooleanClause.Occur.SHOULD;//..MUST;
		    }
            // eliminate empty char, comma or something else from searched string
            // or use as is
            // Split input string 
		    String[] searchDataArray = inputField1Vs.Split(',',' ');
		    String strSearchDataArray = "";
		    for (int i = 0; i < searchDataArray.Length; i++)
		    {
		        strSearchDataArray = strSearchDataArray + searchDataArray[i].ToString() + "~" + sim + " ";
		    }
		    inputField1Vs = inputField1Vs.ToLower();

            // search start:
            // search with term and MUST
		    String[] fNew1 =  {field[1]};
            String fInput1 = field[1];// inputField2;
		    Console.WriteLine(" ");
		    Console.WriteLine("\n-----------*******----------");
		    Console.WriteLine(" search with term and MUST");
		    indexSearcher = new IndexSearcher(directory,true);// true for much better performance
		    
		    BooleanQuery bq1 = new  BooleanQuery();
		    Term t1 = new Term(fInput1, inputField1Vs);
		    Query query1 = new TermQuery(t1);
		    bq1.Add(query1, Lucene.Net.Search.BooleanClause.Occur.MUST);
		    Console.WriteLine(" Query:  " + bq1);		    
            TopDocs docs1 = indexSearcher.Search(bq1, 10);
            Console.WriteLine(" totalHits:  " + docs1.totalHits + "; MaxScore: " + docs1.GetMaxScore());
		    runQueryAndDisplayResults(fNew1,directory, bq1);
		    indexSearcher.Close();
            ////////////////////////////////////////////////////////////////////    

            // search with term and SHOULD
		    String[] fNew11 =  {field[1]};
            String fInput11 = inputField2;
		    Console.WriteLine(" ");
		    Console.WriteLine("\n-----------*******----------");
		    Console.WriteLine(" search with term and SHOULD");
		    indexSearcher = new IndexSearcher(directory,true);
		    BooleanQuery bq11 = new  BooleanQuery();
		    Term t11 = new Term(fInput11, inputField1Vs);
		    Query query11 = new TermQuery(t11);
		    bq11.Add(query11, Lucene.Net.Search.BooleanClause.Occur.SHOULD);
		    Console.WriteLine(" Query:  " + bq11);
		     
             TopDocs   docs11 = indexSearcher.Search(bq11,10); 
             Console.WriteLine(" totalHits:  " + docs11.totalHits + "; MaxScore: " + docs11.GetMaxScore());
		    runQueryAndDisplayResults(fNew11,directory, bq11);//query11) ;
		    indexSearcher.Close();
            //////////////////////////////////////////////////////////////////////

            // PhraseQuery Example
		    String[] fNew111 =  {field[1]};
            String fInput111 = inputField2;
		    Console.WriteLine(" ");
		    Console.WriteLine("\n-----------*******----------");
		    Console.WriteLine(" search with PhraseQuery ");
		    
		    indexSearcher = new IndexSearcher(directory,true);
		    PhraseQuery pq = new  PhraseQuery();  
		    Term t111 = new Term(fInput111, inputField1Vs);    
		    pq.Add(t111 );             
		    Query query111 = new TermQuery(t11);
            Console.WriteLine(" Term Query compare with PhraseQuery:  " + query111 );
		    Console.WriteLine(" Query:  " + pq);		  
            TopDocs docs111 = indexSearcher.Search(pq,10);   
		    runQueryAndDisplayResults(fNew111,directory, pq) ;
		    indexSearcher.Close();
            //////////////////////////////////////////////////////////////////

            // search with parse and MUST
		    String[] fNew12 =  {field[1]};
            String fInput12 = inputField2;
		    Console.WriteLine(" ");
		    Console.WriteLine("\n-----------*******----------");
		    Console.WriteLine(" search with parse and MUST and SHOULD ");
		    indexSearcher = new IndexSearcher(directory);//,true);
		    BooleanQuery bq12 = new  BooleanQuery();

            QueryParser queryParser12 = new QueryParser(Lucene.Net.Util.Version.LUCENE_29, fInput12,
                            analyzer); 		    
		    Query query12  = queryParser12.Parse(inputField1Vs);
		  
		    bq12.Add(query12, Lucene.Net.Search.BooleanClause.Occur.MUST);
		    Console.WriteLine(" Query: MUST: " + query12);		   
            TopDocs docs12 = indexSearcher.Search(query12,10);
            Console.WriteLine(" totalHits:  " + docs12.totalHits + "; MaxScore: " + docs12.GetMaxScore());
		    runQueryAndDisplayResults(fNew12,directory, query12) ;
		    
		    BooleanQuery bq13 = new  BooleanQuery();
		    bq13.Add(query12, Lucene.Net.Search.BooleanClause.Occur.SHOULD);
		    Console.WriteLine(" Query: SHOULD " + query12);		 
            TopDocs docs13 = indexSearcher.Search(query12,10);
            Console.WriteLine(" totalHits:  " + docs13.totalHits + "; MaxScore: " + docs13.GetMaxScore());
		    runQueryAndDisplayResults(fNew12,directory, query12) ;
		    indexSearcher.Close();

            ///////////////////////////////////////////////////  
            // PhraseQuery Example

		   // Console.WriteLine("\n****** PhraseQuery Example ******");
		    String[] fNew121 =  {field[0]};
            String fInput121 = field[1];// inputField1;
		    Console.WriteLine(" ");
		    Console.WriteLine("\n-----------*******----------");
		    Console.WriteLine(" search with PhraseQuery  ");
		    indexSearcher = new IndexSearcher(directory);//,true);
		      
		    PhraseQuery pq121 = new  PhraseQuery();  
		    Term t121 = new Term(fInput121, inputField1Vs);
		    
		    pq121.Add(t121 );
		    Console.WriteLine(" Query: PhraseQuery " + pq121);		    
            TopDocs docs121 = indexSearcher.Search(pq121,10);
            Console.WriteLine(" totalHits:  " + docs121.totalHits + "; MaxScore: " + docs121.GetMaxScore());
            runQueryAndDisplayResults(fNew121,directory, pq121) ;
		    indexSearcher.Close();

            /////////////////////////////////////////////////////

            // fuzzy search
		    Console.WriteLine(" ");
		    Console.WriteLine("\n-----------*******----------");
		    Console.WriteLine(" search with FuzzyQuery and term  ");
		    indexSearcher = new IndexSearcher(directory);//,true);      
		    
		    Term t20 = new Term(fInput121, inputField1Vs);
		    Query  query20 = new FuzzyQuery(t20);
		    Console.WriteLine(" Query: term for fuzzy " + query20);		     
            TopDocs docs20 = indexSearcher.Search(query20,10);
            Console.WriteLine(" totalHits:  " + docs20.totalHits + "; MaxScore: " + docs20.GetMaxScore());
		    runQueryAndDisplayResults(fNew121,directory, query20) ;
		    indexSearcher.Close();
            //////////////////////////////////////////////

            //MultiFieldQueryParser for all fields 		  
		    Console.WriteLine(" ");
		    Console.WriteLine("\n-----------*******----------");
		    Console.WriteLine(" search with MultiFieldQueryParser full text  ");
		    Console.WriteLine(" ");
		    indexSearcher = new IndexSearcher(directory,true);
            // MultiFieldQueryParser.parse static method
            /* MultiFieldQueryParser mfqp = new MultiFieldQueryParser(Version.LUCENE_29,
                     field,
                     analyzer);*/           
            
		    Query queryMFQP =   MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29,strSearchDataArray, field, flags, analyzer);
                
		    
		    Console.WriteLine(" Query: term for full text, separated each word with simulariry " + queryMFQP);	
	        TopDocs docs21 = indexSearcher.Search(queryMFQP,10);
            Console.WriteLine(" totalHits:  " + docs21.totalHits + "; MaxScore: " + docs21.GetMaxScore());
		    
		    runQueryAndDisplayResults(field,directory, queryMFQP) ;
            indexSearcher.Close();
		    
		  }

		  
		  public void 
			runQueryAndDisplayResults(String[] searchedField,Directory indexStore, Query q) 
			 {
			    int hitsPerPage = 10;	  
			    IndexSearcher searcher = new IndexSearcher(indexStore,true);
				int fieldSize = searchedField.Length;
			    String[] field = new String[fieldSize] ;//	
                Console.WriteLine(" ");
			    for(int i = 0; i < fieldSize; i++){    	
			    	field[i] = searchedField[i];
			    	Console.WriteLine((i + 1) + ".Field: "  + field[i] + " ; ");	
			    }	
              TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerPage, true);
				searcher.Search(q, collector);
                Console.WriteLine(" Query :" + q);
				ScoreDoc[] hits = collector.TopDocs().scoreDocs;                
				 
				int _length = hits.Length;
				Console.WriteLine("HITS: " + _length);	
				for (int i = 0; i < _length; i++) {
                    // detail info for score calculating 
					Console.WriteLine("Explain : " + searcher.Explain(q, i).ToString());
				    Document d = searcher.Doc(i);                  
                    float score =  hits[i].score;
				    Console.WriteLine((i + 1) + ". Score:"  + score);
				    for(int j = 0; j<fieldSize;j++){
                        Console.WriteLine(" Field: " + field[j] + ":" + d.Get(field[j]));
				    }
				   	    
				}
			
				searcher.Close();
			}
	}
}

For questions or comments on this site: webmaster@walnUtilsoft.com
For questions about WalnUtil Product: developer@walnUtilsoft.com
Contact us: igorchirok@hotmail.com or call: 1-416-707-7189
All content Copyright © 2010 Igmar Software.All rights reserved.

Current / Total number of users browsing the site: 1 / 2138