QueryTermExtractor.cs

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Lucene.Net.Index;
using Lucene.Net.Util;

namespace Lucene.Net.Search.Highlight
{
    
    public static class QueryTermExtractor
    {
        
        public static WeightedTerm[] GetTerms(Query query)
        {
            return GetTerms(query, false);
        }
        
        public static WeightedTerm[] GetIdfWeightedTerms(Query query, IndexReader reader, string fieldName)
        {
            WeightedTerm[] terms = GetTerms(query, false, fieldName);
            int totalNumDocs = reader.NumDocs();
            foreach (WeightedTerm t in terms)
            {
                try
                {
                    int docFreq = reader.DocFreq(new Term(fieldName, t.Term));
                    // docFreq counts deletes
                    if (totalNumDocs < docFreq)
                    {
                        docFreq = totalNumDocs;
                    }
                    //IDF algorithm taken from DefaultSimilarity class
                    var idf = (float)(Math.Log((float)totalNumDocs / (double)(docFreq + 1)) + 1.0);
                    t.Weight *= idf;
                }
                catch (IOException e)
                {
                    //ignore 
                }
            }
            return terms;
        }
        
        public static WeightedTerm[] GetTerms(Query query, bool prohibited, string fieldName)
        {
            var terms = new HashSet<WeightedTerm>();
            if (fieldName != null)
            {
                fieldName = StringHelper.Intern(fieldName);
            }
            GetTerms(query, terms, prohibited, fieldName);
            return terms.ToArray();
        }
        
        public static WeightedTerm[] GetTerms(Query query, bool prohibited)
        {
            return GetTerms(query, prohibited, null);
        }
        
        //fieldname MUST be interned prior to this call
        private static void GetTerms(Query query, HashSet<WeightedTerm> terms, bool prohibited, string fieldName)
        {
            try
            {
                if (query is BooleanQuery)
                    GetTermsFromBooleanQuery((BooleanQuery) query, terms, prohibited, fieldName);
                else if (query is FilteredQuery)
                    GetTermsFromFilteredQuery((FilteredQuery) query, terms, prohibited, fieldName);
                else
                {
                    var nonWeightedTerms = Support.Compatibility.SetFactory.CreateHashSet<Term>();
                    query.ExtractTerms(nonWeightedTerms);
                    foreach (var term in nonWeightedTerms)
                    {
                        if ((fieldName == null) || (term.Field == fieldName))
                        {
                            terms.Add(new WeightedTerm(query.Boost, term.Text));
                        }
                    }
                }
            }
            catch (System.NotSupportedException ignore)
            {
                //this is non-fatal for our purposes
            }
        }

        private static void  GetTermsFromBooleanQuery(BooleanQuery query, HashSet<WeightedTerm> terms, bool prohibited, string fieldName)
        {
            BooleanClause[] queryClauses = query.GetClauses();
            for (int i = 0; i < queryClauses.Length; i++)
            {
                if (prohibited || queryClauses[i].Occur != Occur.MUST_NOT)
                    GetTerms(queryClauses[i].Query, terms, prohibited, fieldName);
            }
        }
        private static void GetTermsFromFilteredQuery(FilteredQuery query, HashSet<WeightedTerm> terms, bool prohibited, string fieldName)
        {
            GetTerms(query.Query, terms, prohibited, fieldName);
        }
    }
}