Java StandardQueryParser.parse方法代码示例

import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser; //导入方法依赖的package包/类
/**
 * Tries to parse a query string in order to check if it is valid.
 * @param query a Lucene query string
 * @return the query if valid, or '*' if invalid
 */
static String qs(String query) {
	if (StringUtils.isBlank(query) || "*".equals(query.trim())) {
		return "*";
	}
	query = query.trim();
	if (query.length() > 1 && query.startsWith("*")) {
		query = query.substring(1);
	}
	try {
		StandardQueryParser parser = new StandardQueryParser();
		parser.setAllowLeadingWildcard(false);
		parser.parse(query, "");
	} catch (Exception ex) {
		logger.warn("Failed to parse query string '{}'.", query);
		query = "*";
	}
	return query.trim();
}
 

import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser; //导入方法依赖的package包/类
@Override
public Query parseQuery(QueryContext context, IndexName name, 
                        String defaultField, String query) {
    FullTextIndexInfo index = getIndex(context.getSession(), name, null);
    if (defaultField == null) {
        defaultField = index.getDefaultFieldName();
    }
    StandardQueryParser parser = index.getParser();
    try {
        synchronized (parser) {
            return parser.parse(query, defaultField);
        }
    }
    catch (QueryNodeException ex) {
        throw new FullTextQueryParseException(ex);
    }
}
 

import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser; //导入方法依赖的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.StandardQueryParser; //导入方法依赖的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.StandardQueryParser; //导入方法依赖的package包/类
static Query qsParsed(String query) {
	if (StringUtils.isBlank(query) || "*".equals(query.trim())) {
		return null;
	}
	try {
		StandardQueryParser parser = new StandardQueryParser();
		parser.setAllowLeadingWildcard(false);
		return parser.parse(query, "");
	} catch (Exception ex) {
		logger.warn("Failed to parse query string '{}'.", query);
	}
	return null;
}
 

import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser; //导入方法依赖的package包/类
public void testSimple() throws Exception {
    Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_41);
    StandardQueryParser parser = new StandardQueryParser(analyzer);
    Query q = null;
    try {
        q = parser.parse("(agile OR extreme) AND methodology", "subject");
    }
    catch (QueryNodeException exc) {
        // TODO: handle exc
    }
    LOGGER.info("parsed " + q);
}
 

import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser; //导入方法依赖的package包/类
public void testPhraseQuery() throws Exception {
    Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_41);
    StandardQueryParser parser = new CustomFlexibleQueryParser(analyzer);

    Query query = parser.parse("singleTerm", "subject");
    assertTrue("TermQuery", query instanceof TermQuery);

    query = parser.parse("\"a phrase test\"", "subject");
    LOGGER.info("got query=" + query);
    assertTrue("SpanNearQuery", query instanceof SpanNearQuery);
}
 

import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser; //导入方法依赖的package包/类
@Test
public void testTermQuery() throws CorruptIndexException, IOException,
    QueryNodeException {
  
  Document doc = new Document();
  doc.add(new Field("content", "I work for the united nations",
      TextField.TYPE_STORED));
  
  writer.addDocument(doc);
  
  searcher = new IndexSearcher(DirectoryReader.open(writer, false));
  
  StandardQueryParser parser = new StandardQueryParser(new SimpleAnalyzer(
      matchVersion));
  
  Query query = parser.parse("united nations", "content");
  
  Assert.assertEquals(1, TestUtil.hitCount(searcher, query));
  
}