Java QueryParser.Operator方法代码示例

import org.apache.solr.parser.QueryParser; //导入方法依赖的package包/类
@Override
public Query parse() throws SyntaxError {
  String qstr = getString();

  String defaultField = getParam(CommonParams.DF);
  if (defaultField == null) {
    defaultField = getReq().getSchema().getDefaultSearchFieldName();
  }

  lparser = new ComplexPhraseQueryParser(defaultField, getReq().getSchema().getQueryAnalyzer());

  if (localParams != null)
    inOrder = localParams.getBool("inOrder", inOrder);

  lparser.setInOrder(inOrder);

  QueryParser.Operator defaultOperator = QueryParsing.getQueryParserDefaultOperator(getReq().getSchema(), getParam(QueryParsing.OP));

  if (QueryParser.Operator.AND.equals(defaultOperator))
    lparser.setDefaultOperator(org.apache.lucene.queryparser.classic.QueryParser.Operator.AND);
  else
    lparser.setDefaultOperator(org.apache.lucene.queryparser.classic.QueryParser.Operator.OR);

  try {
    return lparser.parse(qstr);
  } catch (ParseException pe) {
    throw new SyntaxError(pe);
  }
}
 

import org.apache.solr.parser.QueryParser; //导入方法依赖的package包/类
public SpanQParser(String qstr, SolrParams localParams, SolrParams params, SolrQueryRequest req){
    super(qstr, localParams, params, req);
    IndexSchema schema = req.getSchema();

    //preamble to initializing the parser
    Analyzer analyzer;

    defaultFieldName = getDefaultField(schema);

    SchemaField sf = schema.getField(defaultFieldName);
    if(sf != null && sf.getType() != null)
      analyzer = sf.getType().getQueryAnalyzer();
    else
      analyzer = schema.getQueryAnalyzer();	//default analyzer?

    //initialize the parser
    parser = new SolrSpanQueryParser(defaultFieldName, analyzer, schema, this);

    //now set the params
    SolrParams solrParams = SolrParams.wrapDefaults(localParams, params);

    parser.setAllowLeadingWildcard(solrParams.getBool(ALLOW_LEADING_WILDCARD, true));

//    parser.setAnalyzeRangeTerms(solrParams.getBool(ANALYZE_RANGE_TERMS, true));
    parser.setAutoGeneratePhraseQueries(solrParams.getBool(AUTO_GENERATE_PHRASE, false));
    QueryParser.Operator defaultOp = 
        QueryParsing.getQueryParserDefaultOperator(req.getSchema(), solrParams.get(QueryParsing.OP));

    if (defaultOp == QueryParser.Operator.AND) {
      parser.setDefaultOperator(Operator.AND);
    }
    parser.setFuzzyMaxEdits(solrParams.getInt(MAX_FUZZY_EDITS, 2));
    parser.setFuzzyPrefixLength(solrParams.getInt(PREFIX_LENGTH, 0));
    parser.setPhraseSlop(solrParams.getInt(PHRASE_SLOP, 0));
    parser.setSpanNearMaxDistance(solrParams.getInt(NEAR_MAX, -1));
    parser.setSpanNotNearMaxDistance(solrParams.getInt(NOT_NEAR_MAX, -1));

  }
 

import org.apache.solr.parser.QueryParser; //导入方法依赖的package包/类
public SimpleQParser (String qstr, SolrParams localParams, SolrParams params, SolrQueryRequest req) {

      super(qstr, localParams, params, req);
      // Some of the parameters may come in through localParams, so combine them with params.
      SolrParams defaultParams = SolrParams.wrapDefaults(localParams, params);

      // This will be used to specify what fields and boosts will be used by SimpleQueryParser.
      Map<String, Float> queryFields = SolrPluginUtils.parseFieldBoosts(defaultParams.get(SimpleParams.QF));

      if (queryFields.isEmpty()) {
        // It qf is not specified setup up the queryFields map to use the defaultField.
        String defaultField = QueryParsing.getDefaultField(req.getSchema(), defaultParams.get(CommonParams.DF));

        if (defaultField == null) {
          // A query cannot be run without having a field or set of fields to run against.
          throw new IllegalStateException("Neither " + SimpleParams.QF + ", " + CommonParams.DF
              + ", nor the default search field are present.");
        }

        queryFields.put(defaultField, 1.0F);
      }
      else {
        for (Map.Entry<String, Float> queryField : queryFields.entrySet()) {
          if (queryField.getValue() == null) {
            // Some fields may be specified without a boost, so default the boost to 1.0 since a null value
            // will not be accepted by SimpleQueryParser.
            queryField.setValue(1.0F);
          }
        }
      }

      // Setup the operations that are enabled for the query.
      int enabledOps = 0;
      String opParam = defaultParams.get(SimpleParams.QO);

      if (opParam == null) {
        // All operations will be enabled.
        enabledOps = -1;
      } else {
        // Parse the specified enabled operations to be used by the query.
        String[] operations = opParam.split(",");

        for (String operation : operations) {
          Integer enabledOp = OPERATORS.get(operation.trim().toUpperCase(Locale.ROOT));

          if (enabledOp != null) {
            enabledOps |= enabledOp;
          }
        }
      }

      // Create a SimpleQueryParser using the analyzer from the schema.
      final IndexSchema schema = req.getSchema();
      parser = new SolrSimpleQueryParser(req.getSchema().getQueryAnalyzer(), queryFields, enabledOps, this, schema);

      // Set the default operator to be either 'AND' or 'OR' for the query.
      QueryParser.Operator defaultOp = QueryParsing.getQueryParserDefaultOperator(req.getSchema(), defaultParams.get(QueryParsing.OP));

      if (defaultOp == QueryParser.Operator.AND) {
        parser.setDefaultOperator(BooleanClause.Occur.MUST);
      }
    }
 

import org.apache.solr.parser.QueryParser; //导入方法依赖的package包/类
public SimpleQParser (String qstr, SolrParams localParams, SolrParams params, SolrQueryRequest req) {

      super(qstr, localParams, params, req);
      // Some of the parameters may come in through localParams, so combine them with params.
      SolrParams defaultParams = SolrParams.wrapDefaults(localParams, params);

      // This will be used to specify what fields and boosts will be used by SimpleQueryParser.
      Map<String, Float> queryFields = SolrPluginUtils.parseFieldBoosts(defaultParams.get(SimpleParams.QF));

      if (queryFields.isEmpty()) {
        // It qf is not specified setup up the queryFields map to use the defaultField.
        String defaultField = QueryParsing.getDefaultField(req.getSchema(), defaultParams.get(CommonParams.DF));

        if (defaultField == null) {
          // A query cannot be run without having a field or set of fields to run against.
          throw new IllegalStateException("Neither " + SimpleParams.QF + ", " + CommonParams.DF
              + ", nor the default search field are present.");
        }

        queryFields.put(defaultField, 1.0F);
      }
      else {
        for (Map.Entry<String, Float> queryField : queryFields.entrySet()) {
          if (queryField.getValue() == null) {
            // Some fields may be specified without a boost, so default the boost to 1.0 since a null value
            // will not be accepted by SimpleQueryParser.
            queryField.setValue(1.0F);
          }
        }
      }

      // Setup the operations that are enabled for the query.
      int enabledOps = 0;
      String opParam = defaultParams.get(SimpleParams.QO);

      if (opParam == null) {
        // All operations will be enabled.
        enabledOps = -1;
      } else {
        // Parse the specified enabled operations to be used by the query.
        String[] operations = opParam.split(",");

        for (String operation : operations) {
          Integer enabledOp = OPERATORS.get(operation.trim().toUpperCase(Locale.ROOT));

          if (enabledOp != null) {
            enabledOps |= enabledOp;
          }
        }
      }

      // Create a SimpleQueryParser using the analyzer from the schema.
      final IndexSchema schema = req.getSchema();
      parser = new SolrSimpleQueryParser(req.getSchema().getAnalyzer(), queryFields, enabledOps, this, schema);

      // Set the default operator to be either 'AND' or 'OR' for the query.
      QueryParser.Operator defaultOp = QueryParsing.getQueryParserDefaultOperator(req.getSchema(), defaultParams.get(QueryParsing.OP));

      if (defaultOp == QueryParser.Operator.AND) {
        parser.setDefaultOperator(BooleanClause.Occur.MUST);
      }
    }
 

import org.apache.solr.parser.QueryParser; //导入方法依赖的package包/类
/**
 * Returns the "preferred" default operator for use by Query Parsers,
 * based on the settings in the IndexSchema which may be overridden using 
 * an optional String override value.
 *
 * @see IndexSchema#getQueryParserDefaultOperator()
 * @see #OP
 */
public static QueryParser.Operator getQueryParserDefaultOperator(final IndexSchema sch,
                                                     final String override) {
  String val = override;
  if (null == val) val = sch.getQueryParserDefaultOperator();
  return "AND".equals(val) ? QueryParser.Operator.AND : QueryParser.Operator.OR;
}