import org.apache.lucene.queries.ChainedFilter; //导入依赖的package包/类
public Query getRangeQuery(QParser parser, SchemaField field, final CurrencyValue p1, final CurrencyValue p2, final boolean minInclusive, final boolean maxInclusive) {
  String currencyCode = (p1 != null) ? p1.getCurrencyCode() :
                        (p2 != null) ? p2.getCurrencyCode() : defaultCurrency;

  // ValueSourceRangeFilter doesn't check exists(), so we have to
  final Filter docsWithValues = new FieldValueFilter(getAmountField(field).getName());
  final Filter vsRangeFilter = new ValueSourceRangeFilter
    (new RawCurrencyValueSource(field, currencyCode, parser),
     p1 == null ? null : p1.getAmount() + "", 
     p2 == null ? null : p2.getAmount() + "",
     minInclusive, maxInclusive);
  final Filter docsInRange = new ChainedFilter
    (new Filter [] { docsWithValues, vsRangeFilter }, ChainedFilter.AND);

  return new SolrConstantScoreQuery(docsInRange);
  
}
 

import org.apache.lucene.queries.ChainedFilter; //导入依赖的package包/类
/**
 * Returns all filters in a OR operation
 */
private static Filter chain(final int logic, Filter... filters) {
    filters = normalize(filters);
    if (ArrayUtils.isEmpty(filters)) {
        return null;
    }
    return new ChainedFilter(filters, logic);
}
 

import org.apache.lucene.queries.ChainedFilter; //导入依赖的package包/类
@Override
public DocIdSet getDocIdSet(AtomicReaderContext context, final Bits acceptDocs) throws IOException {
  Bits docsWithField;
  if (field == null) {
    docsWithField = null;//all docs
  } else {
    //NOTE By using the FieldCache we re-use a cache
    // which is nice but loading it in this way might be slower than say using an
    // intersects filter against the world bounds. So do we add a method to the
    // strategy, perhaps?  But the strategy can't cache it.
    docsWithField = FieldCache.DEFAULT.getDocsWithField(context.reader(), field);

    final int maxDoc = context.reader().maxDoc();
    if (docsWithField.length() != maxDoc )
      throw new IllegalStateException("Bits length should be maxDoc ("+maxDoc+") but wasn't: "+docsWithField);

    if (docsWithField instanceof Bits.MatchNoBits) {
      return null;//match nothing
    } else if (docsWithField instanceof Bits.MatchAllBits) {
      docsWithField = null;//all docs
    }
  }

  //not so much a chain but a way to conveniently invert the Filter
  DocIdSet docIdSet = new ChainedFilter(new Filter[]{intersectsFilter}, ChainedFilter.ANDNOT).getDocIdSet(context, acceptDocs);
  return BitsFilteredDocIdSet.wrap(docIdSet, docsWithField);
}
 

import org.apache.lucene.queries.ChainedFilter; //导入依赖的package包/类
public void testAND() throws Exception {
    ChainedFilter chain = new ChainedFilter(new Filter[] { dateFilter, bobFilter }, ChainedFilter.AND);
    TopDocs hits = searcher.search(query, chain, 10);
    assertEquals("AND matches just Bob", MAX / 2, hits.totalHits);
    StoredDocument firstDoc = searcher.doc(hits.scoreDocs[0].doc);
    assertEquals("bob", firstDoc.get("owner"));
}
 

import org.apache.lucene.queries.ChainedFilter; //导入依赖的package包/类
public void testXOR() throws Exception {
    ChainedFilter chain = new ChainedFilter(new Filter[] { dateFilter, bobFilter }, ChainedFilter.XOR);
    TopDocs hits = searcher.search(query, chain, 10);
    assertEquals("XOR matches Sue", MAX / 2, hits.totalHits);
    StoredDocument firstDoc = searcher.doc(hits.scoreDocs[0].doc);
    assertEquals("sue", firstDoc.get("owner"));
}
 

import org.apache.lucene.queries.ChainedFilter; //导入依赖的package包/类
public void testANDNOT() throws Exception {
    ChainedFilter chain = new ChainedFilter(new Filter[] { dateFilter, sueFilter }, new int[] { ChainedFilter.AND,
            ChainedFilter.ANDNOT });

    TopDocs hits = searcher.search(query, chain, 10);
    assertEquals("ANDNOT matches just Bob", MAX / 2, hits.totalHits);
    StoredDocument firstDoc = searcher.doc(hits.scoreDocs[0].doc);
    assertEquals("bob", firstDoc.get("owner"));
}
 

import org.apache.lucene.queries.ChainedFilter; //导入依赖的package包/类
/**
 * Returns all filters in a AND operation
 */
public static Filter and(final Filter... filters) {
    return chain(ChainedFilter.AND, filters);
}
 

import org.apache.lucene.queries.ChainedFilter; //导入依赖的package包/类
/**
 * Returns all filters in a ANDNOT operation
 */
public static Filter andNot(final Filter... filters) {
    return chain(ChainedFilter.ANDNOT, filters);
}
 

import org.apache.lucene.queries.ChainedFilter; //导入依赖的package包/类
/**
 * Returns all filters in a OR operation
 */
public static Filter or(final Filter... filters) {
    return chain(ChainedFilter.OR, filters);
}
 

import org.apache.lucene.queries.ChainedFilter; //导入依赖的package包/类
public void testOR() throws Exception {
    ChainedFilter chain = new ChainedFilter(new Filter[] { sueFilter, bobFilter });

    assertEquals("OR matches all", MAX, TestUtil.hitCount(searcher, query, chain));
}