Java SolrPluginUtils.setMinShouldMatch方法代码示例

import org.apache.solr.util.SolrPluginUtils; //导入方法依赖的package包/类
protected Query getUserQuery(String userQuery, SolrPluginUtils.DisjunctionMaxQueryParser up, SolrParams solrParams)
        throws SyntaxError {


  String minShouldMatch = parseMinShouldMatch(req.getSchema(), solrParams);
  Query dis = up.parse(userQuery);
  Query query = dis;

  if (dis instanceof BooleanQuery) {
    BooleanQuery t = new BooleanQuery();
    SolrPluginUtils.flattenBooleanQuery(t, (BooleanQuery) dis);
    SolrPluginUtils.setMinShouldMatch(t, minShouldMatch);
    query = t;
  }
  return query;
}
 

import org.apache.solr.util.SolrPluginUtils; //导入方法依赖的package包/类
/**
 * @param query
 */
public Query applyMinShouldMatch(final Query query) {

    if (!(query instanceof BooleanQuery)) {
        return query;
    }

    final BooleanQuery bq = (BooleanQuery) query;
    List<BooleanClause> clauses = bq.clauses();
    if (clauses.size() < 2) {
        return bq;
    }

    for (BooleanClause clause : clauses) {
        if ((clause.getQuery() instanceof BooleanQuery) && (clause.getOccur() != Occur.MUST)) {
            return bq; // seems to be a complex query with sub queries - do not
            // apply mm
        }
    }

    return SolrPluginUtils.setMinShouldMatch(bq, config.getMinShouldMatch());

}
 

import org.apache.solr.util.SolrPluginUtils; //导入方法依赖的package包/类
public Query getOrQuery(){
    BooleanQuery.Builder qryBuilder = new BooleanQuery.Builder();
    for(RFTerm RFTerm : this.RFTerms){
        qryBuilder.add(toBoostedQuery(RFTerm), BooleanClause.Occur.SHOULD);
    }
    SolrPluginUtils.setMinShouldMatch(qryBuilder, mm);
    return qryBuilder.build();
}
 

import org.apache.solr.util.SolrPluginUtils; //导入方法依赖的package包/类
/**
 * Parses an escaped version of the user's query.  This method is called 
 * in the event that the original query encounters exceptions during parsing.
 *
 * @param up parser used
 * @param escapedUserQuery query that is parsed, should already be escaped so that no trivial parse errors are encountered
 * @param config Configuration options for this parse request
 * @return the resulting query (flattened if needed) with "min should match" rules applied as specified in the config.
 * @see #parseOriginalQuery
 * @see SolrPluginUtils#flattenBooleanQuery
 */
protected Query parseEscapedQuery(ExtendedSolrQueryParser up,
    String escapedUserQuery, ExtendedDismaxConfiguration config) throws SyntaxError {
  Query query = up.parse(escapedUserQuery);
  
  if (query instanceof BooleanQuery) {
    BooleanQuery t = new BooleanQuery();
    SolrPluginUtils.flattenBooleanQuery(t, (BooleanQuery)query);
    SolrPluginUtils.setMinShouldMatch(t, config.minShouldMatch);
    query = t;
  }
  return query;
}
 

import org.apache.solr.util.SolrPluginUtils; //导入方法依赖的package包/类
/**
 * Parses the user's original query.  This method attempts to cleanly parse the specified query string using the specified parser, any Exceptions are ignored resulting in null being returned.
 *
 * @param up parser used
 * @param mainUserQuery query string that is parsed
 * @param clauses used to dictate "min should match" logic
 * @param config Configuration options for this parse request
 * @return the resulting query with "min should match" rules applied as specified in the config.
 * @see #parseEscapedQuery
 */
 protected Query parseOriginalQuery(ExtendedSolrQueryParser up,
    String mainUserQuery, List<Clause> clauses, ExtendedDismaxConfiguration config) {
  
  Query query = null;
  try {
    up.setRemoveStopFilter(!config.stopwords);
    up.exceptions = true;
    query = up.parse(mainUserQuery);
    
    if (shouldRemoveStopFilter(config, query)) {
      // if the query was all stop words, remove none of them
      up.setRemoveStopFilter(true);
      query = up.parse(mainUserQuery);          
    }
  } catch (Exception e) {
    // ignore failure and reparse later after escaping reserved chars
    up.exceptions = false;
  }
  
  if(query == null) {
    return null;
  }
  // For correct lucene queries, turn off mm processing if there
  // were explicit operators (except for AND).
  boolean doMinMatched = doMinMatched(clauses, config.lowercaseOperators);
  if (doMinMatched && query instanceof BooleanQuery) {
    SolrPluginUtils.setMinShouldMatch((BooleanQuery)query, config.minShouldMatch);
  }
  return query;
}
 

import org.apache.solr.util.SolrPluginUtils; //导入方法依赖的package包/类
public Query getOrQuery(){
    BooleanQuery.Builder qryBuilder = new BooleanQuery.Builder();
    for(MLTTerm mltTerm: this.mltTerms){
        qryBuilder.add(toBoostedQuery(mltTerm), BooleanClause.Occur.SHOULD);
    }
    SolrPluginUtils.setMinShouldMatch(qryBuilder, mm);
    return qryBuilder.build();
}
 

import org.apache.solr.util.SolrPluginUtils; //导入方法依赖的package包/类
@Test                                    
public void testMinShouldMatchCalculator() {

  /* zero is zero is zero */
  assertEquals(0, calcMSM(5, "0"));
  assertEquals(0, calcMSM(5, "0%"));
  assertEquals(0, calcMSM(5, " -5 "));
  assertEquals(0, calcMSM(5, "\n -100% \n"));

  /* basic integers */
  assertEquals(3, calcMSM(5, " \n3\n "));
  assertEquals(2, calcMSM(5, "-3"));
  assertEquals(3, calcMSM(3, "3"));
  assertEquals(0, calcMSM(3, "-3"));
  assertEquals(3, calcMSM(3, "5"));
  assertEquals(0, calcMSM(3, "-5"));

  /* positive percentages with rounding */
  assertEquals(0, calcMSM(3, " \n25% \n"));
  assertEquals(1, calcMSM(4, "25%"));
  assertEquals(1, calcMSM(5, " 25% "));
  assertEquals(2, calcMSM(10, "25%"));
      
  /* negative percentages with rounding */
  assertEquals(3, calcMSM(3, " \n-25%\n "));
  assertEquals(3, calcMSM(4, "-25%"));
  assertEquals(4, calcMSM(5, "-25%"));
  assertEquals(8, calcMSM(10, "-25%"));

  /* conditional */
  assertEquals(1, calcMSM(1, "3<0"));
  assertEquals(2, calcMSM(2, "3<0"));
  assertEquals(3, calcMSM(3, "3<0"));
  assertEquals(0, calcMSM(4, "3<0"));
  assertEquals(0, calcMSM(5, "3<0"));
  assertEquals(1, calcMSM(1, "3<25%"));
  assertEquals(2, calcMSM(2, " 3\n<\n25% "));
  assertEquals(3, calcMSM(3, "3<25%"));
  assertEquals(1, calcMSM(4, "\n 3 < \n25%\n "));
  assertEquals(1, calcMSM(5, "3<25%"));

  /* multiple conditionals */
  assertEquals(1, calcMSM(1, "\n3 < -25% 10 < -3 \n"));
  assertEquals(2, calcMSM(2, " 3 < -25% 10 < -3\n"));
  assertEquals(3, calcMSM(3, " 3 < -25% \n 10 < -3 \n"));
  assertEquals(3, calcMSM(4, " 3 < -25% 10 < -3 "));
  assertEquals(4, calcMSM(5, " 3 < -25% 10 < -3"));
  assertEquals(5, calcMSM(6, "3<-25% 10<-3"));
  assertEquals(6, calcMSM(7, " 3 < -25% 10 < -3 "));
  assertEquals(6, calcMSM(8, " 3 < -25% 10 \n < -3\n"));
  assertEquals(7, calcMSM(9, " 3 < -25% 10 < -3 \n"));
  assertEquals(8, calcMSM(10, " 3 < -25% 10 < -3"));
  assertEquals(8, calcMSM(11, "3<-25% 10<-3"));
  assertEquals(9, calcMSM(12, "3<-25% 10<-3"));
  assertEquals(97, calcMSM(100, "3<-25% 10<-3"));

  BooleanQuery q = new BooleanQuery();
  q.add(new TermQuery(new Term("a","b")), Occur.SHOULD);
  q.add(new TermQuery(new Term("a","c")), Occur.SHOULD);
  q.add(new TermQuery(new Term("a","d")), Occur.SHOULD);
  q.add(new TermQuery(new Term("a","d")), Occur.SHOULD);

  SolrPluginUtils.setMinShouldMatch(q, "0");
  assertEquals(0, q.getMinimumNumberShouldMatch());
      
  SolrPluginUtils.setMinShouldMatch(q, "1");
  assertEquals(1, q.getMinimumNumberShouldMatch());
      
  SolrPluginUtils.setMinShouldMatch(q, "50%");
  assertEquals(2, q.getMinimumNumberShouldMatch());

  SolrPluginUtils.setMinShouldMatch(q, "99");
  assertEquals(4, q.getMinimumNumberShouldMatch());

  q.add(new TermQuery(new Term("a","e")), Occur.MUST);
  q.add(new TermQuery(new Term("a","f")), Occur.MUST);

  SolrPluginUtils.setMinShouldMatch(q, "50%");
  assertEquals(2, q.getMinimumNumberShouldMatch());
      
}