Java TermsQuery类代码示例

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
public Query getFilter() {
    boolean hasFilters = false;
    List<Term> termsList = new ArrayList<>();

    if (genre != null && genre.trim().length() > 0) {
        hasFilters = true;
        termsList.add(new Term(TrackField.GENRE.name(), genre.trim()));
    }

    if (year != null && year.trim().length() > 0) {
        hasFilters = true;
        termsList.add(new Term(TrackField.YEAR.name(), year.trim()));
    }

    if (hasFilters) {
        return new TermsQuery(termsList);
    }

    return null;
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
@Test
public void shouldUseTermsQuery() throws SyntaxError, IOException {
  when(localParamsMock.get("command")).thenReturn("smembers");
  when(localParamsMock.get("key")).thenReturn("simpleKey");
  when(localParamsMock.get("ignoreScore")).thenReturn("true");
  when(localParamsMock.getBool("useAnalyzer", false)).thenReturn(true);
  when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field");
  when(requestMock.getSchema()).thenReturn(schema);
  when(schema.getQueryAnalyzer()).thenReturn(new WhitespaceAnalyzer());
  when(jedisMock.smembers(anyString())).thenReturn(new HashSet<>(Arrays.asList("123 124", "321", "322", "323", "324",
          "325", "326", "327", "328", "329", "330", "331", "332", "333", "334", "335", "336", "337", "338")));
  redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler);
  final Query query = redisQParser.parse();
  verify(jedisMock).smembers("simpleKey");
  IndexSearcher searcher = new IndexSearcher(new MultiReader());
  Query rewrittenQuery = searcher.rewrite(query);
  assertTrue(rewrittenQuery instanceof TermsQuery);
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
private static Query termsQuery(String columnName, Literal arrayLiteral) {
    List<Term> terms = getTerms(columnName, arrayLiteral);
    if (terms.isEmpty()) {
        return new MatchNoDocsQuery();
    }
    return new TermsQuery(terms);
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
@Override
public Query apply(Function input, Context context) {
    Tuple<Reference, Literal> tuple = super.prepare(input);
    if (tuple == null) {
        return null;
    }
    Reference reference = tuple.v1();
    Literal literal = tuple.v2();
    String columnName = reference.info().ident().columnIdent().fqn();
    if (DataTypes.isCollectionType(reference.valueType()) && DataTypes.isCollectionType(literal.valueType())) {
        List<Term> terms = getTerms(columnName, literal);
        if (terms.isEmpty()) {
            return genericFunctionFilter(input, context);
        }
        Query termsQuery = new TermsQuery(terms);

        // wrap boolTermsFilter and genericFunction filter in an additional BooleanFilter to control the ordering of the filters
        // termsFilter is applied first
        // afterwards the more expensive genericFunctionFilter
        BooleanQuery.Builder filterClauses = new BooleanQuery.Builder();
        filterClauses.add(termsQuery, BooleanClause.Occur.MUST);
        filterClauses.add(genericFunctionFilter(input, context), BooleanClause.Occur.MUST);
        return filterClauses.build();
    }
    QueryBuilderHelper builder = QueryBuilderHelper.forType(tuple.v1().valueType());
    return builder.eq(columnName, tuple.v2().value());
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
static boolean isCostly(Query query) {
  // This does not measure the cost of iterating over the filter (for this we
  // already have the DocIdSetIterator#cost API) but the cost to build the
  // DocIdSet in the first place
  // ========== BEGIN EDIT ==========
  /*return query instanceof MultiTermQuery ||
      query instanceof MultiTermQueryConstantScoreWrapper;*/
  return query instanceof MultiTermQuery ||
      query instanceof MultiTermQueryConstantScoreWrapper ||
      query instanceof TermsQuery;
  // ========== END EDIT ==========
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
private static void handleExclude(BooleanQuery boolQuery, List<Item> likeItems) {
    // artificial docs get assigned a random id and should be disregarded
    List<BytesRef> uids = new ArrayList<>();
    for (Item item : likeItems) {
        if (item.doc() != null) {
            continue;
        }
        uids.add(createUidAsBytes(item.type(), item.id()));
    }
    if (!uids.isEmpty()) {
        TermsQuery query = new TermsQuery(UidFieldMapper.NAME, uids.toArray(new BytesRef[0]));
        boolQuery.add(query, BooleanClause.Occur.MUST_NOT);
    }
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
@Override
public Query termQuery(Object value, @Nullable QueryParseContext context) {
    if (indexOptions() != IndexOptions.NONE || context == null) {
        return super.termQuery(value, context);
    }
    final BytesRef[] uids = Uid.createUidsForTypesAndId(context.queryTypes(), value);
    return new TermsQuery(UidFieldMapper.NAME, uids);
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
@Override
public Query termsQuery(List values, @Nullable QueryParseContext context) {
    if (indexOptions() != IndexOptions.NONE || context == null) {
        return super.termsQuery(values, context);
    }
    return new TermsQuery(UidFieldMapper.NAME, Uid.createUidsForTypesAndIds(context.queryTypes(), values));
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
public Query termsQuery(List values, @Nullable QueryParseContext context) {
    BytesRef[] bytesRefs = new BytesRef[values.size()];
    for (int i = 0; i < bytesRefs.length; i++) {
        bytesRefs[i] = indexedValueForSearch(values.get(i));
    }
    return new TermsQuery(names.indexName(), bytesRefs);
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
private void addChromosomeFilter(BooleanQuery.Builder builder) {
    if (CollectionUtils.isNotEmpty(chromosomeIds)) {
        List<Term> chromosomeTerms = chromosomeIds.stream().map(id -> new Term(FeatureIndexFields.CHROMOSOME_ID
                        .getFieldName(), id.toString())).collect(Collectors.toList());
        builder.add(new TermsQuery(chromosomeTerms), BooleanClause.Occur.MUST);
    }
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
private void addVcfFileFilter(BooleanQuery.Builder builder) {
    if (vcfFileIds != null && !vcfFileIds.isEmpty()) {
        List<Term> terms = vcfFileIds.stream()
                .map(vcfFileId -> new Term(FeatureIndexFields.FILE_ID.getFieldName(), vcfFileId.toString()))
                .collect(Collectors.toList());
        TermsQuery termsQuery = new TermsQuery(terms);
        builder.add(termsQuery, BooleanClause.Occur.MUST);
    }
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
@Test
public void shouldInitialiseWithGenre() {
    TrackFilter trackFilter = new TrackFilter("Genre", null);
    TermsQuery termsQuery = (TermsQuery)trackFilter.getFilter();

    assertThat("Filter query should have 1 term", termsQuery.getTermData().size(), equalTo(1l));
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
@Test
public void shouldInitialiseWithYear() {
    TrackFilter trackFilter = new TrackFilter(null, "2000");
    TermsQuery termsQuery = (TermsQuery)trackFilter.getFilter();

    assertThat("Filter query should have 1 term", termsQuery.getTermData().size(), equalTo(1l));
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
@Test
public void shouldInitialiseWithGenreAndYear() {
    TrackFilter trackFilter = new TrackFilter("Genre", "2000");
    TermsQuery termsQuery = (TermsQuery)trackFilter.getFilter();

    assertThat("Filter query should have 2 terms", termsQuery.getTermData().size(), equalTo(2l));
}
 

import org.apache.lucene.queries.TermsQuery; //导入依赖的package包/类
@Override
public Query termsQuery(List<?> values, QueryShardContext context) {
    failIfNotIndexed();
    BytesRef[] bytesRefs = new BytesRef[values.size()];
    for (int i = 0; i < bytesRefs.length; i++) {
        bytesRefs[i] = indexedValueForSearch(values.get(i));
    }
    return new TermsQuery(name(), bytesRefs);
}