Exemplo n.º 1
0
  public void testMultiFieldBQ3() throws Exception {
    BooleanQuery.Builder query = new BooleanQuery.Builder();
    query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
    query.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);

    qtest(query.build(), new int[] {0, 1, 2, 3});
  }
Exemplo n.º 2
0
  public void testBQ19() throws Exception {
    BooleanQuery.Builder query = new BooleanQuery.Builder();
    query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST_NOT);
    query.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.SHOULD);

    qtest(query.build(), new int[] {0, 1});
  }
  public void testQueries() throws Exception {
    single = single(random());
    parallel = parallel(random());

    queryTest(new TermQuery(new Term("f1", "v1")));
    queryTest(new TermQuery(new Term("f1", "v2")));
    queryTest(new TermQuery(new Term("f2", "v1")));
    queryTest(new TermQuery(new Term("f2", "v2")));
    queryTest(new TermQuery(new Term("f3", "v1")));
    queryTest(new TermQuery(new Term("f3", "v2")));
    queryTest(new TermQuery(new Term("f4", "v1")));
    queryTest(new TermQuery(new Term("f4", "v2")));

    BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
    bq1.add(new TermQuery(new Term("f1", "v1")), Occur.MUST);
    bq1.add(new TermQuery(new Term("f4", "v1")), Occur.MUST);
    queryTest(bq1.build());

    single.getIndexReader().close();
    single = null;
    parallel.getIndexReader().close();
    parallel = null;
    dir.close();
    dir = null;
    dir1.close();
    dir1 = null;
    dir2.close();
    dir2 = null;
  }
Exemplo n.º 4
0
 public void testBQ15() throws Exception {
   BooleanQuery.Builder q = new BooleanQuery.Builder();
   q.setDisableCoord(true);
   q.add(new TermQuery(new Term(FIELD, "QQQQQ")), BooleanClause.Occur.MUST_NOT);
   q.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
   qtest(q.build(), new int[] {0, 1, 2, 3});
 }
Exemplo n.º 5
0
  public void testBQ11() throws Exception {
    BooleanQuery.Builder query = new BooleanQuery.Builder();
    query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
    TermQuery boostedQuery = new TermQuery(new Term(FIELD, "w1"));
    query.add(new BoostQuery(boostedQuery, 1000), BooleanClause.Occur.SHOULD);

    qtest(query.build(), new int[] {0, 1, 2, 3});
  }
Exemplo n.º 6
0
  public void testDMQ7() throws Exception {
    BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
    booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST_NOT);
    booleanQuery.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.SHOULD);

    DisjunctionMaxQuery q =
        new DisjunctionMaxQuery(
            Arrays.asList(booleanQuery.build(), new TermQuery(new Term(FIELD, "w2"))), 0.5f);
    qtest(q, new int[] {0, 1, 2, 3});
  }
Exemplo n.º 7
0
  public void testMultiFieldBQofPQ7() throws Exception {
    BooleanQuery.Builder query = new BooleanQuery.Builder();

    PhraseQuery leftChild = new PhraseQuery(3, FIELD, "w3", "w2");
    query.add(leftChild, BooleanClause.Occur.SHOULD);

    PhraseQuery rightChild = new PhraseQuery(1, ALTFIELD, "w3", "w2");
    query.add(rightChild, BooleanClause.Occur.SHOULD);

    qtest(query.build(), new int[] {0, 1, 2, 3});
  }
Exemplo n.º 8
0
  public void testDMQ8() throws Exception {
    BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
    booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);

    TermQuery boostedQuery = new TermQuery(new Term(FIELD, "w5"));
    booleanQuery.add(new BoostQuery(boostedQuery, 100), BooleanClause.Occur.SHOULD);

    TermQuery xxBoostedQuery = new TermQuery(new Term(FIELD, "xx"));

    DisjunctionMaxQuery q =
        new DisjunctionMaxQuery(
            Arrays.asList(booleanQuery.build(), new BoostQuery(xxBoostedQuery, 100000)), 0.5f);
    qtest(q, new int[] {0, 2, 3});
  }
 @Override
 public Query searchFilter(String[] types) {
   Query filter = mapperService().searchFilter(types);
   if (filter == null && aliasFilter == null) {
     return null;
   }
   BooleanQuery.Builder bq = new BooleanQuery.Builder();
   if (filter != null) {
     bq.add(filter, Occur.MUST);
   }
   if (aliasFilter != null) {
     bq.add(aliasFilter, Occur.MUST);
   }
   return new ConstantScoreQuery(bq.build());
 }
Exemplo n.º 10
0
  public void testMultiFieldBQ6() throws Exception {
    BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
    outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);

    BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
    innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.MUST_NOT);
    innerQuery.add(new TermQuery(new Term(ALTFIELD, "w5")), BooleanClause.Occur.SHOULD);
    outerQuery.add(innerQuery.build(), BooleanClause.Occur.MUST_NOT);

    qtest(outerQuery.build(), new int[] {1, 2, 3});
  }
Exemplo n.º 11
0
  public void testBQ5() throws Exception {
    BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
    outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);

    BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
    innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.MUST);
    innerQuery.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
    outerQuery.add(innerQuery.build(), BooleanClause.Occur.SHOULD);

    qtest(outerQuery.build(), new int[] {0, 1, 2, 3});
  }
  @Override
  public Query rewrite(IndexReader reader) {
    // short-circuit to match all if specifying the whole map
    if (minLon == GeoUtils.MIN_LON_INCL
        && maxLon == GeoUtils.MAX_LON_INCL
        && minLat == GeoUtils.MIN_LAT_INCL
        && maxLat == GeoUtils.MAX_LAT_INCL) {
      // FieldValueQuery is valid since DocValues are *required* for GeoPointField
      return new FieldValueQuery(field);
    }

    if (maxLon < minLon) {
      BooleanQuery.Builder bqb = new BooleanQuery.Builder();

      GeoPointInBBoxQueryImpl left =
          new GeoPointInBBoxQueryImpl(field, -180.0D, minLat, maxLon, maxLat);
      bqb.add(new BooleanClause(left, BooleanClause.Occur.SHOULD));
      GeoPointInBBoxQueryImpl right =
          new GeoPointInBBoxQueryImpl(field, minLon, minLat, 180.0D, maxLat);
      bqb.add(new BooleanClause(right, BooleanClause.Occur.SHOULD));
      return bqb.build();
    }
    return new GeoPointInBBoxQueryImpl(field, minLon, minLat, maxLon, maxLat);
  }
Exemplo n.º 13
0
  public void testBQ20() throws Exception {
    BooleanQuery.Builder q = new BooleanQuery.Builder();
    q.setMinimumNumberShouldMatch(2);
    q.add(new TermQuery(new Term(FIELD, "QQQQQ")), BooleanClause.Occur.SHOULD);
    q.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
    q.add(new TermQuery(new Term(FIELD, "zz")), BooleanClause.Occur.SHOULD);
    q.add(new TermQuery(new Term(FIELD, "w5")), BooleanClause.Occur.SHOULD);
    q.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.SHOULD);

    qtest(q.build(), new int[] {0, 3});
  }
Exemplo n.º 14
0
 public void testBQ26() throws Exception {
   BooleanQuery.Builder query = new BooleanQuery.Builder();
   query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.FILTER);
   query.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
   qtest(query.build(), new int[] {0, 1});
 }
  public void testDuelTermsQuery() throws IOException {
    final int iters = atLeast(2);
    for (int iter = 0; iter < iters; ++iter) {
      final List<Long> allNumbers = new ArrayList<>();
      final int numNumbers = TestUtil.nextInt(random(), 1, 1 << TestUtil.nextInt(random(), 1, 10));
      for (int i = 0; i < numNumbers; ++i) {
        allNumbers.add(random().nextLong());
      }
      Directory dir = newDirectory();
      RandomIndexWriter iw = new RandomIndexWriter(random(), dir);
      final int numDocs = atLeast(100);
      for (int i = 0; i < numDocs; ++i) {
        Document doc = new Document();
        final Long number = allNumbers.get(random().nextInt(allNumbers.size()));
        doc.add(new StringField("text", number.toString(), Store.NO));
        doc.add(new NumericDocValuesField("long", number));
        doc.add(new SortedNumericDocValuesField("twolongs", number));
        doc.add(new SortedNumericDocValuesField("twolongs", number * 2));
        iw.addDocument(doc);
      }
      if (numNumbers > 1 && random().nextBoolean()) {
        iw.deleteDocuments(new TermQuery(new Term("text", allNumbers.get(0).toString())));
      }
      iw.commit();
      final IndexReader reader = iw.getReader();
      final IndexSearcher searcher = newSearcher(reader);
      iw.close();

      if (reader.numDocs() == 0) {
        // may occasionally happen if all documents got the same term
        IOUtils.close(reader, dir);
        continue;
      }

      for (int i = 0; i < 100; ++i) {
        final float boost = random().nextFloat() * 10;
        final int numQueryNumbers =
            TestUtil.nextInt(random(), 1, 1 << TestUtil.nextInt(random(), 1, 8));
        Set<Long> queryNumbers = new HashSet<>();
        Set<Long> queryNumbersX2 = new HashSet<>();
        for (int j = 0; j < numQueryNumbers; ++j) {
          Long number = allNumbers.get(random().nextInt(allNumbers.size()));
          queryNumbers.add(number);
          queryNumbersX2.add(2 * number);
        }
        final BooleanQuery.Builder bq = new BooleanQuery.Builder();
        for (Long number : queryNumbers) {
          bq.add(new TermQuery(new Term("text", number.toString())), Occur.SHOULD);
        }
        Query q1 = new BoostQuery(new ConstantScoreQuery(bq.build()), boost);

        Query q2 = new BoostQuery(new DocValuesNumbersQuery("long", queryNumbers), boost);
        assertSameMatches(searcher, q1, q2, true);

        Query q3 = new BoostQuery(new DocValuesNumbersQuery("twolongs", queryNumbers), boost);
        assertSameMatches(searcher, q1, q3, true);

        Query q4 = new BoostQuery(new DocValuesNumbersQuery("twolongs", queryNumbersX2), boost);
        assertSameMatches(searcher, q1, q4, true);
      }

      reader.close();
      dir.close();
    }
  }
Exemplo n.º 16
0
 public void testBQ24() throws Exception {
   BooleanQuery.Builder query = new BooleanQuery.Builder();
   query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.FILTER);
   query.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
   qtest(query.build(), new int[] {0, 1, 2, 3});
 }
Exemplo n.º 17
0
  public void testMultiFieldBQ10() throws Exception {
    BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
    outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);

    BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
    innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.SHOULD);

    BooleanQuery.Builder childLeft = new BooleanQuery.Builder();
    childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
    childLeft.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.SHOULD);
    innerQuery.add(childLeft.build(), BooleanClause.Occur.SHOULD);

    BooleanQuery.Builder childRight = new BooleanQuery.Builder();
    childRight.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
    childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
    innerQuery.add(childRight.build(), BooleanClause.Occur.MUST_NOT);

    outerQuery.add(innerQuery.build(), BooleanClause.Occur.MUST);

    qtest(outerQuery.build(), new int[] {1});
  }