← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/contrib/queries/src/java/org/apache/lucene/search/BoostingQuery.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/contrib/queries/src/java/org/apache/lucene/search/BoostingQuery.java
1
 
package org.apache.lucene.search;
2
 
 
3
 
/**
4
 
 * Licensed to the Apache Software Foundation (ASF) under one or more
5
 
 * contributor license agreements.  See the NOTICE file distributed with
6
 
 * this work for additional information regarding copyright ownership.
7
 
 * The ASF licenses this file to You under the Apache License, Version 2.0
8
 
 * (the "License"); you may not use this file except in compliance with
9
 
 * the License.  You may obtain a copy of the License at
10
 
 *
11
 
 *     http://www.apache.org/licenses/LICENSE-2.0
12
 
 *
13
 
 * Unless required by applicable law or agreed to in writing, software
14
 
 * distributed under the License is distributed on an "AS IS" BASIS,
15
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16
 
 * See the License for the specific language governing permissions and
17
 
 * limitations under the License.
18
 
 */
19
 
 
20
 
import java.io.IOException;
21
 
 
22
 
import org.apache.lucene.index.IndexReader;
23
 
import org.apache.lucene.search.BooleanQuery;
24
 
import org.apache.lucene.search.DefaultSimilarity;
25
 
import org.apache.lucene.search.Query;
26
 
import org.apache.lucene.search.Searcher;
27
 
import org.apache.lucene.search.Similarity;
28
 
/**
29
 
 * The BoostingQuery class can be used to effectively demote results that match a given query. 
30
 
 * Unlike the "NOT" clause, this still selects documents that contain undesirable terms, 
31
 
 * but reduces their overall score:
32
 
 *
33
 
 *     Query balancedQuery = new BoostingQuery(positiveQuery, negativeQuery, 0.01f);
34
 
 * In this scenario the positiveQuery contains the mandatory, desirable criteria which is used to 
35
 
 * select all matching documents, and the negativeQuery contains the undesirable elements which 
36
 
 * are simply used to lessen the scores. Documents that match the negativeQuery have their score 
37
 
 * multiplied by the supplied "boost" parameter, so this should be less than 1 to achieve a 
38
 
 * demoting effect
39
 
 * 
40
 
 * This code was originally made available here: [WWW] http://marc.theaimsgroup.com/?l=lucene-user&m=108058407130459&w=2
41
 
 * and is documented here: http://wiki.apache.org/lucene-java/CommunityContributions
42
 
 */
43
 
public class BoostingQuery extends Query {
44
 
    private float boost;                            // the amount to boost by
45
 
    private Query match;                            // query to match
46
 
    private Query context;                          // boost when matches too
47
 
 
48
 
    public BoostingQuery(Query match, Query context, float boost) {
49
 
      this.match = match;
50
 
      this.context = (Query)context.clone();        // clone before boost
51
 
      this.boost = boost;
52
 
 
53
 
      this.context.setBoost(0.0f);                      // ignore context-only matches
54
 
    }
55
 
 
56
 
    @Override
57
 
    public Query rewrite(IndexReader reader) throws IOException {
58
 
      BooleanQuery result = new BooleanQuery() {
59
 
 
60
 
        @Override
61
 
        public Similarity getSimilarity(Searcher searcher) {
62
 
          return new DefaultSimilarity() {
63
 
 
64
 
            @Override
65
 
            public float coord(int overlap, int max) {
66
 
              switch (overlap) {
67
 
 
68
 
              case 1:                               // matched only one clause
69
 
                return 1.0f;                        // use the score as-is
70
 
 
71
 
              case 2:                               // matched both clauses
72
 
                return boost;                       // multiply by boost
73
 
 
74
 
              default:
75
 
                return 0.0f;
76
 
                
77
 
              }
78
 
            }
79
 
          };
80
 
        }
81
 
      };
82
 
 
83
 
      result.add(match, BooleanClause.Occur.MUST);
84
 
      result.add(context, BooleanClause.Occur.SHOULD);
85
 
 
86
 
      return result;
87
 
    }
88
 
 
89
 
    @Override
90
 
    public int hashCode() {
91
 
      final int prime = 31;
92
 
      int result = 1;
93
 
      result = prime * result + Float.floatToIntBits(boost);
94
 
      result = prime * result + ((context == null) ? 0 : context.hashCode());
95
 
      result = prime * result + ((match == null) ? 0 : match.hashCode());
96
 
      return result;
97
 
    }
98
 
 
99
 
    @Override
100
 
    public boolean equals(Object obj) {
101
 
      if (this == obj)
102
 
        return true;
103
 
      if (obj == null)
104
 
        return false;
105
 
      if (getClass() != obj.getClass())
106
 
        return false;
107
 
      BoostingQuery other = (BoostingQuery) obj;
108
 
      if (Float.floatToIntBits(boost) != Float.floatToIntBits(other.boost))
109
 
        return false;
110
 
      if (context == null) {
111
 
        if (other.context != null)
112
 
          return false;
113
 
      } else if (!context.equals(other.context))
114
 
        return false;
115
 
      if (match == null) {
116
 
        if (other.match != null)
117
 
          return false;
118
 
      } else if (!match.equals(other.match))
119
 
        return false;
120
 
      return true;
121
 
    }
122
 
 
123
 
    @Override
124
 
    public String toString(String field) {
125
 
      return match.toString(field) + "/" + context.toString(field);
126
 
    }
127
 
  }