Java SolrPluginUtils.DisjunctionMaxQueryParser方法代码示例

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包/类
/** Adds the main query to the query argument. If its blank then false is returned. */
protected boolean addMainQuery(BooleanQuery query, SolrParams solrParams) throws SyntaxError {
  Map<String, Float> phraseFields = SolrPluginUtils.parseFieldBoosts(solrParams.getParams(DisMaxParams.PF));
  float tiebreaker = solrParams.getFloat(DisMaxParams.TIE, 0.0f);

  /* a parser for dealing with user input, which will convert
   * things to DisjunctionMaxQueries
   */
  SolrPluginUtils.DisjunctionMaxQueryParser up = getParser(queryFields, DisMaxParams.QS, solrParams, tiebreaker);

  /* for parsing sloppy phrases using DisjunctionMaxQueries */
  SolrPluginUtils.DisjunctionMaxQueryParser pp = getParser(phraseFields, DisMaxParams.PS, solrParams, tiebreaker);

  /* * * Main User Query * * */
  parsedUserQuery = null;
  String userQuery = getString();
  altUserQuery = null;
  if (userQuery == null || userQuery.trim().length() < 1) {
    // If no query is specified, we may have an alternate
    altUserQuery = getAlternateUserQuery(solrParams);
    if (altUserQuery == null)
      return false;
    query.add(altUserQuery, BooleanClause.Occur.MUST);
  } else {
    // There is a valid query string
    userQuery = SolrPluginUtils.partialEscape(SolrPluginUtils.stripUnbalancedQuotes(userQuery)).toString();
    userQuery = SolrPluginUtils.stripIllegalOperators(userQuery).toString();

    parsedUserQuery = getUserQuery(userQuery, up, solrParams);
    query.add(parsedUserQuery, BooleanClause.Occur.MUST);

    Query phrase = getPhraseQuery(userQuery, pp);
    if (null != phrase) {
      query.add(phrase, BooleanClause.Occur.SHOULD);
    }
  }
  return true;
}
 

import org.apache.solr.util.SolrPluginUtils; //导入方法依赖的package包/类
protected Query getPhraseQuery(String userQuery, SolrPluginUtils.DisjunctionMaxQueryParser pp) throws SyntaxError {
  /* * * Add on Phrases for the Query * * */

  /* build up phrase boosting queries */

  /* if the userQuery already has some quotes, strip them out.
   * we've already done the phrases they asked for in the main
   * part of the query, this is to boost docs that may not have
   * matched those phrases but do match looser phrases.
  */
  String userPhraseQuery = userQuery.replace("\"", "");
  return pp.parse("\"" + userPhraseQuery + "\"");
}
 

import org.apache.solr.util.SolrPluginUtils; //导入方法依赖的package包/类
protected SolrPluginUtils.DisjunctionMaxQueryParser getParser(Map<String, Float> fields, String paramName,
                                                              SolrParams solrParams, float tiebreaker) {
  int slop = solrParams.getInt(paramName, 0);
  SolrPluginUtils.DisjunctionMaxQueryParser parser = new SolrPluginUtils.DisjunctionMaxQueryParser(this,
          IMPOSSIBLE_FIELD_NAME);
  parser.addAlias(IMPOSSIBLE_FIELD_NAME, tiebreaker, fields);
  parser.setPhraseSlop(slop);
  return parser;
}