source: trunk/indexers/lucene-gs/src/org/greenstone/LuceneWrapper/GS2LuceneQuery.java@ 12372

/**
 *
 * @author  [email protected]
 * @author  [email protected]
 * @version 
 */

package org.nzdl.gsdl.LuceneWrap;


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Iterator;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Searcher;
import org.apache.lucene.search.Sort;


public class GS2LuceneQuery
{
    public static void main (String args[])
    {
    if (args.length == 0) {
        System.out.println("Usage: GS2LuceneQuery <index directory> (<sort field>)");
        return;
    }

        try {
        Searcher searcher = new IndexSearcher(args[0]);
        IndexReader reader = ((IndexSearcher) searcher).getIndexReader();

        Sort sorter = new Sort();

            // New code to allow the default conjunction operator to be
            // definable
            String default_conjuction_operator = "OR";
            for (int i = 1; i < args.length; i++)
                {
                    if (args[i].equals("-sort"))
                        {
                            i++;
                            sorter = new Sort(args[i]);
                        }
                    if (args[i].equals("-dco"))
                        {
                            i++;
                            default_conjuction_operator = args[i];
                        }
                }

        // Create one query parser with the standard set of stop words, and one with none
        QueryParser query_parser = new QueryParser("TX", new StandardAnalyzer());
        QueryParser query_parser_no_stop_words = new QueryParser("TX", new StandardAnalyzer(new String[] { }));

        // Lucene does "OR" queries by default; do an "AND" query if specified
        if (default_conjuction_operator.equals("AND")) {
        query_parser.setDefaultOperator(query_parser.AND_OPERATOR);
        query_parser_no_stop_words.setDefaultOperator(query_parser.AND_OPERATOR);
        }

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
        while (true) {
        // Read the query from STDIN
        String query_string = in.readLine();
        if (query_string == null || query_string.length() == -1) {
            break;
        }
        System.err.println("**** query = " + query_string);

        // Parse the query and rewrite it into individual terms (eg. for wildcard searches)
        Query query = query_parser.parse(query_string);
        query = query.rewrite(reader);
        Query query_including_stop_words = query_parser_no_stop_words.parse(query_string);
        query_including_stop_words = query_including_stop_words.rewrite(reader);

        // Perform the query
        Hits hits = searcher.search(query, sorter);
        System.out.println("<ResultSet>");
        System.out.println("  <QueryString>" + query_string + "</QueryString>");

        // Return the list of expanded query terms and their frequencies
        HashSet terms = new HashSet();
        query.extractTerms(terms);
        System.out.println("  <QueryTermsInfo num=\"" + terms.size() + "\"/>");
        Iterator terms_iter = terms.iterator();
        while (terms_iter.hasNext()) {
            Term term = (Term) terms_iter.next();
            System.out.println("  <Term value=\"" + term.text() + "\" freq=\"" + reader.docFreq(term) + "\" field=\"" + term.field() + "\"/>");
        }

        // Return the list of stop words removed from the query
        HashSet terms_including_stop_words = new HashSet();
        query_including_stop_words.extractTerms(terms_including_stop_words);
        System.out.println("  <StopWordsInfo num=\"" + (terms_including_stop_words.size() - terms.size()) + "\"/>");
        Iterator terms_including_stop_words_iter = terms_including_stop_words.iterator();
        while (terms_including_stop_words_iter.hasNext()) {
            Term term = (Term) terms_including_stop_words_iter.next();
            if (!terms.contains(term)) {
            System.err.println("  <StopWord value=\"" + term.text() + "\"/>");
            }
        }

        // Return the matching documents
        System.out.println("  <MatchingDocsInfo num=\"" + hits.length() + "\"/>");
        for (int i = 0; i < hits.length(); i++) {
            Document doc = hits.doc(i);
            String node_id = doc.get("nodeID");
            System.out.println("  <Match id=\"" + node_id + "\"/>");
        }

        System.out.println("</ResultSet>");
        }
        
        searcher.close();
    }
    catch (Exception exception) {
        exception.printStackTrace();
        }
    }
}