import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
void initAttributeNumericConfig() {
    NumberFormat numberFormat = NumberFormat.getNumberInstance(Locale.ENGLISH);
    intNumericConfig = new NumericConfig(precisionStep, numberFormat, FieldType.NumericType.INT);
    longNumericConfig = new NumericConfig(precisionStep, numberFormat, FieldType.NumericType.LONG);
    floatNumericConfig = new NumericConfig(precisionStep, numberFormat, FieldType.NumericType.FLOAT);
    doubleNumericConfig = new NumericConfig(precisionStep, numberFormat, FieldType.NumericType.DOUBLE);

    attributeNumericConfigMap = new HashMap<>();
    attributeNumericConfigMap.put(Byte.TYPE, intNumericConfig);
    attributeNumericConfigMap.put(Byte.class, intNumericConfig);
    attributeNumericConfigMap.put(Short.TYPE, intNumericConfig);
    attributeNumericConfigMap.put(Short.class, intNumericConfig);
    attributeNumericConfigMap.put(Integer.TYPE, intNumericConfig);
    attributeNumericConfigMap.put(Integer.class, intNumericConfig);
    attributeNumericConfigMap.put(Long.TYPE, longNumericConfig);
    attributeNumericConfigMap.put(Long.class, longNumericConfig);
    attributeNumericConfigMap.put(Float.TYPE, floatNumericConfig);
    attributeNumericConfigMap.put(Float.class, floatNumericConfig);
    // Statistics of features are stored as Double, but Float is sufficient.
    attributeNumericConfigMap.put(Double.TYPE, floatNumericConfig);
    attributeNumericConfigMap.put(Double.class, floatNumericConfig);
}
 

import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
@Test
public void testRangeParsing() throws Exception {
    NumericConfig numericConfig = new NumericConfig(8, NumberFormat.getNumberInstance(Locale.ENGLISH), FieldType.NumericType.FLOAT);
    HashMap<String, NumericConfig> numericConfigMap = new HashMap<String, NumericConfig>();
    numericConfigMap.put("reflec_7", numericConfig);
    numericConfigMap.put("reflec_8", numericConfig);
    numericConfigMap.put("reflec_9", numericConfig);
    StandardQueryParser parser = new StandardQueryParser();
    parser.setNumericConfigMap(numericConfigMap);

    Query query1 = parser.parse("reflec_8:[0.0 TO 1.0]", "x");
    assertEquals(NumericRangeQuery.class, query1.getClass());

    Query query2 = parser.parse("reflec_8:[0.0 TO 1.0] AND reflec_9:[0.2 TO 0.6]^3.1", "x");
    assertEquals(BooleanQuery.class, query2.getClass());
    BooleanClause clause1 = ((BooleanQuery) query2).getClauses()[0];
    BooleanClause clause2 = ((BooleanQuery) query2).getClauses()[1];
    NumericRangeQuery<Float> nrq1 = NumericRangeQuery.newFloatRange("reflec_8", 8, 0.0F, 1.0F, true, true);
    NumericRangeQuery<Float> nrq2 = NumericRangeQuery.newFloatRange("reflec_9", 8, 0.2F, 0.6F, true, true);
    nrq2.setBoost(3.1F);
    assertEquals(nrq1, clause1.getQuery());
    assertEquals(BooleanClause.Occur.MUST, clause1.getOccur());
    assertEquals(nrq2, clause2.getQuery());
    assertEquals(BooleanClause.Occur.MUST, clause2.getOccur());
}
 

import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
private ExpertRevisionSearchCommand(DirectoryManager.DirectoryPath path, String qry, Configuration configuration)
        throws QueryNodeException {
    super(path, ResultList.ResultType.REVISION);
    setLanguage(extractLanguage(qry));
    Map<String, NumericConfig> nums = new HashMap<>();

    /*StandardQueryParser parser = new StandardQueryParser(getAnalyzer());*/
    StandardQueryParser parser = new StandardQueryParser();
    parser.setAllowLeadingWildcard(true);
    parser.setAnalyzer(getAnalyzer());
    if(!StringUtils.hasText(qry)) {
        throw new ParseException(new MessageImpl("EMPTY_QUERY"));
    }
    query = parser.parse(qry, "general");

    // No matter if we have configuraion or not we'll parse the query twice. This second parsing will add analyzers for known keys like key.id
    // as well as fields found from configuration if configuration is provided
    addAnalyzersAndConfigs(query, nums, configuration);
    parser.setAnalyzer(getAnalyzer());
    parser.setNumericConfigMap(nums);
    query = parser.parse(qry, "general");
}
 

import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
/**
 * Sets the upper and lower bounds of this range query node and the
 * {@link NumericConfig} associated with these bounds.
 * 
 * @param lower the lower bound
 * @param upper the upper bound
 * @param lowerInclusive <code>true</code> if the lower bound is inclusive, otherwise, <code>false</code>
 * @param upperInclusive <code>true</code> if the upper bound is inclusive, otherwise, <code>false</code>
 * @param numericConfig the {@link NumericConfig} that represents associated with the upper and lower bounds
 * 
 */
public void setBounds(NumericQueryNode lower, NumericQueryNode upper,
    boolean lowerInclusive, boolean upperInclusive, NumericConfig numericConfig) throws QueryNodeException {
  
  if (numericConfig == null) {
    throw new IllegalArgumentException("numericConfig cannot be null!");
  }
  
  NumericType lowerNumberType, upperNumberType;
  
  if (lower != null && lower.getValue() != null) {
    lowerNumberType = getNumericDataType(lower.getValue());
  } else {
    lowerNumberType = null;
  }
  
  if (upper != null && upper.getValue() != null) {
    upperNumberType = getNumericDataType(upper.getValue());
  } else {
    upperNumberType = null;
  }
  
  if (lowerNumberType != null
      && !lowerNumberType.equals(numericConfig.getType())) {
    throw new IllegalArgumentException(
        "lower value's type should be the same as numericConfig type: "
            + lowerNumberType + " != " + numericConfig.getType());
  }
  
  if (upperNumberType != null
      && !upperNumberType.equals(numericConfig.getType())) {
    throw new IllegalArgumentException(
        "upper value's type should be the same as numericConfig type: "
            + upperNumberType + " != " + numericConfig.getType());
  }
  
  super.setBounds(lower, upper, lowerInclusive, upperInclusive);
  this.numericConfig = numericConfig;
  
}
 

import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
public Map<String, NumericConfig> getNumericConfigMap(DatasetDescriptor dsDescriptor) {
    initAttributeNumericConfig();
    Map<String, NumericConfig> numericConfigMap = new HashMap<>();
    numericConfigMap.put("id", longNumericConfig);
    numericConfigMap.put("px", intNumericConfig);
    numericConfigMap.put("py", intNumericConfig);
    numericConfigMap.put("rnd", doubleNumericConfig);
    numericConfigMap.put("lat", floatNumericConfig);
    numericConfigMap.put("lon", floatNumericConfig);
    numericConfigMap.put("time", longNumericConfig);
    addAttributeNumericConfigs(dsDescriptor, numericConfigMap);
    return numericConfigMap;
}
 

import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
private void addAnalyzersAndConfigs(Query query, Map<String, NumericConfig> nums, Configuration config) {
    if(query instanceof TermQuery) {
        addTermQuery((TermQuery) query, nums, config);
    } else if(query instanceof MultiTermQuery) {
        addMultiQuery((MultiTermQuery)query, nums, config);
    } else if(query instanceof SpanQuery) {
        addSpanQuery((SpanQuery)query, nums, config);
    } else if(query instanceof BooleanQuery) {
        addBooleanQuery((BooleanQuery)query, nums, config);
    }/* else if(query instanceof PhraseQuery) {
        addPhraseQuery((PhraseQuery)query, nums, config);
    }*/
    // TODO: Some query types might still be missed in which case they don't have correct numeric configurations etc.
}
 

import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
@Override
protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
  
  if (node instanceof FieldQueryNode
      && !(node.getParent() instanceof RangeQueryNode)) {
    
    QueryConfigHandler config = getQueryConfigHandler();
    
    if (config != null) {
      FieldQueryNode fieldNode = (FieldQueryNode) node;
      FieldConfig fieldConfig = config.getFieldConfig(fieldNode
          .getFieldAsString());
      
      if (fieldConfig != null) {
        NumericConfig numericConfig = fieldConfig
            .get(ConfigurationKeys.NUMERIC_CONFIG);
        
        if (numericConfig != null) {
          
          NumberFormat numberFormat = numericConfig.getNumberFormat();
          String text = fieldNode.getTextAsString();
          Number number = null;
          
          if (text.length() > 0) {
            
            try {
              number = numberFormat.parse(text);
              
            } catch (ParseException e) {
              throw new QueryNodeParseException(new MessageImpl(
                  QueryParserMessages.COULD_NOT_PARSE_NUMBER, fieldNode
                      .getTextAsString(), numberFormat.getClass()
                      .getCanonicalName()), e);
            }
            
            switch (numericConfig.getType()) {
              case LONG:
                number = number.longValue();
                break;
              case INT:
                number = number.intValue();
                break;
              case DOUBLE:
                number = number.doubleValue();
                break;
              case FLOAT:
                number = number.floatValue();
            }
            
          } else {
            throw new QueryNodeParseException(new MessageImpl(
                QueryParserMessages.NUMERIC_CANNOT_BE_EMPTY, fieldNode.getFieldAsString()));
          }
          
          NumericQueryNode lowerNode = new NumericQueryNode(fieldNode
              .getField(), number, numberFormat);
          NumericQueryNode upperNode = new NumericQueryNode(fieldNode
              .getField(), number, numberFormat);
          
          return new NumericRangeQueryNode(lowerNode, upperNode, true, true,
              numericConfig);
          
        }
        
      }
      
    }
    
  }
  
  return node;
  
}
 

import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
public void setNumericConfigMap(Map<String,NumericConfig> numericConfigMap) {
  getQueryConfigHandler().set(ConfigurationKeys.NUMERIC_CONFIG_MAP, numericConfigMap);
}
 

import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
public Map<String,NumericConfig> getNumericConfigMap() {
  return getQueryConfigHandler().get(ConfigurationKeys.NUMERIC_CONFIG_MAP);
}
 

import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
@Override
public NumericRangeQuery<? extends Number> build(QueryNode queryNode)
    throws QueryNodeException {
  NumericRangeQueryNode numericRangeNode = (NumericRangeQueryNode) queryNode;
  
  NumericQueryNode lowerNumericNode = numericRangeNode.getLowerBound();
  NumericQueryNode upperNumericNode = numericRangeNode.getUpperBound();
  
  Number lowerNumber = lowerNumericNode.getValue();
  Number upperNumber = upperNumericNode.getValue();
  
  NumericConfig numericConfig = numericRangeNode.getNumericConfig();
  NumericType numberType = numericConfig.getType();
  String field = StringUtils.toString(numericRangeNode.getField());
  boolean minInclusive = numericRangeNode.isLowerInclusive();
  boolean maxInclusive = numericRangeNode.isUpperInclusive();
  int precisionStep = numericConfig.getPrecisionStep();
  
  switch (numberType) {
    
    case LONG:
      return NumericRangeQuery.newLongRange(field, precisionStep,
          (Long) lowerNumber, (Long) upperNumber, minInclusive, maxInclusive);
    
    case INT:
      return NumericRangeQuery.newIntRange(field, precisionStep,
          (Integer) lowerNumber, (Integer) upperNumber, minInclusive,
          maxInclusive);
    
    case FLOAT:
      return NumericRangeQuery.newFloatRange(field, precisionStep,
          (Float) lowerNumber, (Float) upperNumber, minInclusive,
          maxInclusive);
    
    case DOUBLE:
      return NumericRangeQuery.newDoubleRange(field, precisionStep,
          (Double) lowerNumber, (Double) upperNumber, minInclusive,
          maxInclusive);
      
      default :
        throw new QueryNodeException(new MessageImpl(
          QueryParserMessages.UNSUPPORTED_NUMERIC_DATA_TYPE, numberType));
      
  }
}
 

import org.apache.lucene.queryparser.flexible.standard.config.NumericConfig; //导入依赖的package包/类
private NumericConfig getAttributeNumericConfig(AttributeType attributeType) {
    Class<?> valueType = attributeType.getValueType();
    return attributeNumericConfigMap.get(valueType);
}