Java QueryUtils.check方法代码示例

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
public void testBasics() {
    final int iters = scaledRandomIntBetween(5, 25);
    for (int j = 0; j < iters; j++) {
        String[] fields = new String[1 + random().nextInt(10)];
        for (int i = 0; i < fields.length; i++) {
            fields[i] = TestUtil.randomRealisticUnicodeString(random(), 1, 10);
        }
        String term = TestUtil.randomRealisticUnicodeString(random(), 1, 10);
        Term[] terms = toTerms(fields, term);
        boolean disableCoord = random().nextBoolean();
        boolean useBoolean = random().nextBoolean();
        float tieBreaker = random().nextFloat();
        BlendedTermQuery query = useBoolean ? BlendedTermQuery.booleanBlendedQuery(terms, disableCoord) : BlendedTermQuery.dismaxBlendedQuery(terms, tieBreaker);
        QueryUtils.check(query);
        terms = toTerms(fields, term);
        BlendedTermQuery query2 = useBoolean ? BlendedTermQuery.booleanBlendedQuery(terms, disableCoord) : BlendedTermQuery.dismaxBlendedQuery(terms, tieBreaker);
        assertEquals(query, query2);
    }
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
private void doTestRank (ValueSource valueSource) throws Exception {
  FunctionQuery functionQuery = new FunctionQuery(valueSource);
  IndexReader r = DirectoryReader.open(dir);
  IndexSearcher s = newSearcher(r);
  log("test: "+ functionQuery);
  QueryUtils.check(random(), functionQuery,s);
  ScoreDoc[] h = s.search(functionQuery, null, 1000).scoreDocs;
  assertEquals("All docs should be matched!",N_DOCS,h.length);
  String prevID = "ID"+(N_DOCS+1); // greater than all ids of docs in this test
  for (int i=0; i<h.length; i++) {
    String resID = s.doc(h[i].doc).get(ID_FIELD);
    log(i+".   score="+h[i].score+"  -  "+resID);
    log(s.explain(functionQuery,h[i].doc));
    assertTrue("res id "+resID+" should be < prev res id "+prevID, resID.compareTo(prevID)<0);
    prevID = resID;
  }
  r.close();
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
@Test
public void testSpanNearExact() throws Exception {
  SpanTermQuery term1 = new SpanTermQuery(new Term("field", "seventy"));
  SpanTermQuery term2 = new SpanTermQuery(new Term("field", "seven"));
  SpanNearQuery query = new SpanNearQuery(new SpanQuery[] {term1, term2},
                                          0, true);
  checkHits(query, new int[]
    {77, 177, 277, 377, 477, 577, 677, 777, 877, 977, 1077, 1177, 1277, 1377, 1477, 1577, 1677, 1777, 1877, 1977});

  assertTrue(searcher.explain(query, 77).getValue() > 0.0f);
  assertTrue(searcher.explain(query, 977).getValue() > 0.0f);

  QueryUtils.check(term1);
  QueryUtils.check(term2);
  QueryUtils.checkUnequal(term1,term2);
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
public void testAverageFunction() throws IOException {
  PayloadNearQuery query;
  TopDocs hits;

  query = newPhraseQuery("field", "twenty two", true, new AveragePayloadFunction());
  QueryUtils.check(query);
  // all 10 hits should have score = 3 because adjacent terms have payloads of 2,4
  // and all the similarity factors are set to 1
  hits = searcher.search(query, null, 100);
  assertTrue("hits is null and it shouldn't be", hits != null);
  assertTrue("should be 10 hits", hits.totalHits == 10);
  for (int j = 0; j < hits.scoreDocs.length; j++) {
    ScoreDoc doc = hits.scoreDocs[j];
    assertTrue(doc.score + " does not equal: " + 3, doc.score == 3);
    Explanation explain = searcher.explain(query, hits.scoreDocs[j].doc);
    String exp = explain.toString();
    assertTrue(exp, exp.indexOf("AveragePayloadFunction") > -1);
    assertTrue(hits.scoreDocs[j].score + " explain value does not equal: " + 3, explain.getValue() == 3f);
  }
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
public void testMaxFunction() throws IOException {
  PayloadNearQuery query;
  TopDocs hits;

  query = newPhraseQuery("field", "twenty two", true, new MaxPayloadFunction());
  QueryUtils.check(query);
  // all 10 hits should have score = 4 (max payload value)
  hits = searcher.search(query, null, 100);
  assertTrue("hits is null and it shouldn't be", hits != null);
  assertTrue("should be 10 hits", hits.totalHits == 10);
  for (int j = 0; j < hits.scoreDocs.length; j++) {
    ScoreDoc doc = hits.scoreDocs[j];
    assertTrue(doc.score + " does not equal: " + 4, doc.score == 4);
    Explanation explain = searcher.explain(query, hits.scoreDocs[j].doc);
    String exp = explain.toString();
    assertTrue(exp, exp.indexOf("MaxPayloadFunction") > -1);
    assertTrue(hits.scoreDocs[j].score + " explain value does not equal: " + 4, explain.getValue() == 4f);
  }
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
public void testMinFunction() throws IOException {
  PayloadNearQuery query;
  TopDocs hits;

  query = newPhraseQuery("field", "twenty two", true, new MinPayloadFunction());
  QueryUtils.check(query);
  // all 10 hits should have score = 2 (min payload value)
  hits = searcher.search(query, null, 100);
  assertTrue("hits is null and it shouldn't be", hits != null);
  assertTrue("should be 10 hits", hits.totalHits == 10);
  for (int j = 0; j < hits.scoreDocs.length; j++) {
    ScoreDoc doc = hits.scoreDocs[j];
    assertTrue(doc.score + " does not equal: " + 2, doc.score == 2);
    Explanation explain = searcher.explain(query, hits.scoreDocs[j].doc);
    String exp = explain.toString();
    assertTrue(exp, exp.indexOf("MinPayloadFunction") > -1);
    assertTrue(hits.scoreDocs[j].score + " explain value does not equal: " + 2, explain.getValue() == 2f);
  }
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
private void doTestRank (ValueSource valueSource) throws Exception {
  FunctionQuery functionQuery = new FunctionQuery(valueSource);
  IndexReader r = DirectoryReader.open(dir);
  IndexSearcher s = new IndexSearcher(r);
  log("test: "+ functionQuery);
  QueryUtils.check(random(), functionQuery,s);
  ScoreDoc[] h = s.search(functionQuery, null, 1000).scoreDocs;
  assertEquals("All docs should be matched!",N_DOCS,h.length);
  String prevID = "ID"+(N_DOCS+1); // greater than all ids of docs in this test
  for (int i=0; i<h.length; i++) {
    String resID = s.doc(h[i].doc).get(ID_FIELD);
    log(i+".   score="+h[i].score+"  -  "+resID);
    log(s.explain(functionQuery,h[i].doc));
    assertTrue("res id "+resID+" should be < prev res id "+prevID, resID.compareTo(prevID)<0);
    prevID = resID;
  }
  r.close();
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
public void testBasics() {
    MinDocQuery query1 = new MinDocQuery(42);
    MinDocQuery query2 = new MinDocQuery(42);
    MinDocQuery query3 = new MinDocQuery(43);
    QueryUtils.check(query1);
    QueryUtils.checkEqual(query1, query2);
    QueryUtils.checkUnequal(query1, query3);
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
public void testBasics() {
    TermsSliceQuery query1 =
        new TermsSliceQuery("field1", 1, 10);
    TermsSliceQuery query2 =
        new TermsSliceQuery("field1", 1, 10);
    TermsSliceQuery query3 =
        new TermsSliceQuery("field2", 1, 10);
    TermsSliceQuery query4 =
        new TermsSliceQuery("field1", 2, 10);
    QueryUtils.check(query1);
    QueryUtils.checkEqual(query1, query2);
    QueryUtils.checkUnequal(query1, query3);
    QueryUtils.checkUnequal(query1, query4);
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
public void testBasics() {
    DocValuesSliceQuery query1 =
        new DocValuesSliceQuery("field1", 1, 10);
    DocValuesSliceQuery query2 =
        new DocValuesSliceQuery("field1", 1, 10);
    DocValuesSliceQuery query3 =
        new DocValuesSliceQuery("field2", 1, 10);
    DocValuesSliceQuery query4 =
        new DocValuesSliceQuery("field1", 2, 10);
    QueryUtils.check(query1);
    QueryUtils.checkEqual(query1, query2);
    QueryUtils.checkUnequal(query1, query3);
    QueryUtils.checkUnequal(query1, query4);
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
public void testBoostingQueryEquals() {
  TermQuery q1 = new TermQuery(new Term("subject:", "java"));
  TermQuery q2 = new TermQuery(new Term("subject:", "java"));
  assertEquals("Two TermQueries with same attributes should be equal", q1, q2);
  BoostingQuery bq1 = new BoostingQuery(q1, q2, 0.1f);
  QueryUtils.check(bq1);
  BoostingQuery bq2 = new BoostingQuery(q1, q2, 0.1f);
  assertEquals("BoostingQuery with same attributes is not equal", bq1, bq2);
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
public void testQuery() throws IOException {
  IndexSearcher searcher = newSearcher(reader);

  // Making sure the query yields 25 documents with the facet "a"
  DrillDownQuery q = new DrillDownQuery(config);
  q.add("a");
  QueryUtils.check(q);
  TopDocs docs = searcher.search(q, 100);
  assertEquals(25, docs.totalHits);
  
  // Making sure the query yields 5 documents with the facet "b" and the
  // previous (facet "a") query as a base query
  DrillDownQuery q2 = new DrillDownQuery(config, q);
  q2.add("b");
  docs = searcher.search(q2, 100);
  assertEquals(5, docs.totalHits);

  // Making sure that a query of both facet "a" and facet "b" yields 5 results
  DrillDownQuery q3 = new DrillDownQuery(config);
  q3.add("a");
  q3.add("b");
  docs = searcher.search(q3, 100);
  
  assertEquals(5, docs.totalHits);
  // Check that content:foo (which yields 50% results) and facet/b (which yields 20%)
  // would gather together 10 results (10%..) 
  Query fooQuery = new TermQuery(new Term("content", "foo"));
  DrillDownQuery q4 = new DrillDownQuery(config, fooQuery);
  q4.add("b");
  docs = searcher.search(q4, 100);
  assertEquals(10, docs.totalHits);
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
public void testQuery() {
  PayloadTermQuery boostingFuncTermQuery = new PayloadTermQuery(new Term(PayloadHelper.MULTI_FIELD, "seventy"),
      new MaxPayloadFunction());
  QueryUtils.check(boostingFuncTermQuery);
  
  SpanTermQuery spanTermQuery = new SpanTermQuery(new Term(PayloadHelper.MULTI_FIELD, "seventy"));

  assertTrue(boostingFuncTermQuery.equals(spanTermQuery) == spanTermQuery.equals(boostingFuncTermQuery));
  
  PayloadTermQuery boostingFuncTermQuery2 = new PayloadTermQuery(new Term(PayloadHelper.MULTI_FIELD, "seventy"),
      new AveragePayloadFunction());
  
  QueryUtils.checkUnequal(boostingFuncTermQuery, boostingFuncTermQuery2);
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
/**
 * NOTE: defType is not only used to pick the parser, but, if non-null it is 
 * also to record the parser being tested for coverage sanity checking
 *
 * @see QueryUtils#check
 * @see QueryUtils#checkEqual
 * @see #testParserCoverage
 */
protected void assertQueryEquals(final String defType,
                                 final SolrQueryRequest req,
                                 final String... inputs) throws Exception {

  if (null != defType) qParsersTested.add(defType);

  final Query[] queries = new Query[inputs.length];

  try {
    SolrQueryResponse rsp = new SolrQueryResponse();
    SolrRequestInfo.setRequestInfo(new SolrRequestInfo(req,rsp));
    for (int i = 0; i < inputs.length; i++) {
      queries[i] = (QParser.getParser(inputs[i], defType, req).getQuery());
    }
  } finally {
    SolrRequestInfo.clearRequestInfo();
  }

  for (int i = 0; i < queries.length; i++) {
    QueryUtils.check(queries[i]);
    // yes starting j=0 is redundent, we're making sure every query 
    // is equal to itself, and that the quality checks work regardless 
    // of which caller/callee is used.
    for (int j = 0; j < queries.length; j++) {
      QueryUtils.checkEqual(queries[i], queries[j]);
    }
  }
}
 

import org.apache.lucene.search.QueryUtils; //导入方法依赖的package包/类
private void assertQueryEquals(final String defType,
                               final SolrQueryRequest req,
                               final String... inputs) throws Exception {

  if (null != defType) qParsersTested.add(defType);

  final Query[] queries = new Query[inputs.length];

  try {
    SolrQueryResponse rsp = new SolrQueryResponse();
    SolrRequestInfo.setRequestInfo(new SolrRequestInfo(req,rsp));
    for (int i = 0; i < inputs.length; i++) {
      queries[i] = (QParser.getParser(inputs[i], defType, req).getQuery());
    }
    for (int i = 0; i < queries.length; i++) {
      QueryUtils.check(queries[i]);
      // yes starting j=0 is redundent, we're making sure every query
      // is equal to itself, and that the quality checks work regardless
      // of which caller/callee is used.
      for (int j = 0; j < queries.length; j++) {
        QueryUtils.checkEqual(queries[i], queries[j]);
      }
    }
  } finally {
    SolrRequestInfo.clearRequestInfo();
  }
}