import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/** User runs a query and counts facets. */
private List<FacetResult> facetsWithSearch() throws IOException {
  DirectoryReader indexReader = DirectoryReader.open(indexDir);
  IndexSearcher searcher = new IndexSearcher(indexReader);
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);

  FacetsCollector fc = new FacetsCollector();

  // MatchAllDocsQuery is for "browsing" (counts facets
  // for all non-deleted docs in the index); normally
  // you'd use a "normal" query:
  FacetsCollector.search(searcher, new MatchAllDocsQuery(), 10, fc);

  // Retrieve results
  List<FacetResult> results = new ArrayList<FacetResult>();

  // Count both "Publish Date" and "Author" dimensions
  Facets facets = new FastTaxonomyFacetCounts(taxoReader, config, fc);
  results.add(facets.getTopChildren(10, "Author"));
  results.add(facets.getTopChildren(10, "Publish Date"));
  
  indexReader.close();
  taxoReader.close();
  
  return results;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/** User drills down on 'Publish Date/2010', and we
 *  return facets for 'Author' */
private FacetResult drillDown() throws IOException {
  DirectoryReader indexReader = DirectoryReader.open(indexDir);
  IndexSearcher searcher = new IndexSearcher(indexReader);
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);

  // Passing no baseQuery means we drill down on all
  // documents ("browse only"):
  DrillDownQuery q = new DrillDownQuery(config);

  // Now user drills down on Publish Date/2010:
  q.add("Publish Date", "2010");
  FacetsCollector fc = new FacetsCollector();
  FacetsCollector.search(searcher, q, 10, fc);

  // Retrieve results
  Facets facets = new FastTaxonomyFacetCounts(taxoReader, config, fc);
  FacetResult result = facets.getTopChildren(10, "Author");

  indexReader.close();
  taxoReader.close();
  
  return result;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/** User drills down on 'Publish Date/2010', and we
 *  return facets for both 'Publish Date' and 'Author',
 *  using DrillSideways. */
private List<FacetResult> drillSideways() throws IOException {
  DirectoryReader indexReader = DirectoryReader.open(indexDir);
  IndexSearcher searcher = new IndexSearcher(indexReader);
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);

  // Passing no baseQuery means we drill down on all
  // documents ("browse only"):
  DrillDownQuery q = new DrillDownQuery(config);

  // Now user drills down on Publish Date/2010:
  q.add("Publish Date", "2010");

  DrillSideways ds = new DrillSideways(searcher, config, taxoReader);
  DrillSidewaysResult result = ds.search(q, 10);

  // Retrieve results
  List<FacetResult> facets = result.facets.getAllDims(10);

  indexReader.close();
  taxoReader.close();
  
  return facets;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/** User runs a query and aggregates facets by summing their association values. */
private List<FacetResult> sumAssociations() throws IOException {
  DirectoryReader indexReader = DirectoryReader.open(indexDir);
  IndexSearcher searcher = new IndexSearcher(indexReader);
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);
  
  FacetsCollector fc = new FacetsCollector();
  
  // MatchAllDocsQuery is for "browsing" (counts facets
  // for all non-deleted docs in the index); normally
  // you'd use a "normal" query:
  FacetsCollector.search(searcher, new MatchAllDocsQuery(), 10, fc);
  
  Facets tags = new TaxonomyFacetSumIntAssociations("$tags", taxoReader, config, fc);
  Facets genre = new TaxonomyFacetSumFloatAssociations("$genre", taxoReader, config, fc);

  // Retrieve results
  List<FacetResult> results = new ArrayList<FacetResult>();
  results.add(tags.getTopChildren(10, "tags"));
  results.add(genre.getTopChildren(10, "genre"));

  indexReader.close();
  taxoReader.close();
  
  return results;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/** User drills down on 'tags/solr'. */
private FacetResult drillDown() throws IOException {
  DirectoryReader indexReader = DirectoryReader.open(indexDir);
  IndexSearcher searcher = new IndexSearcher(indexReader);
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);

  // Passing no baseQuery means we drill down on all
  // documents ("browse only"):
  DrillDownQuery q = new DrillDownQuery(config);

  // Now user drills down on Publish Date/2010:
  q.add("tags", "solr");
  FacetsCollector fc = new FacetsCollector();
  FacetsCollector.search(searcher, q, 10, fc);

  // Retrieve results
  Facets facets = new TaxonomyFacetSumFloatAssociations("$genre", taxoReader, config, fc);
  FacetResult result = facets.getTopChildren(10, "genre");

  indexReader.close();
  taxoReader.close();
  
  return result;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/** User runs a query and counts facets. */
private List<FacetResult> facetsWithSearch() throws IOException {
  DirectoryReader indexReader = DirectoryReader.open(indexDir);
  IndexSearcher searcher = new IndexSearcher(indexReader);
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);

  FacetsCollector fc = new FacetsCollector();

  // MatchAllDocsQuery is for "browsing" (counts facets
  // for all non-deleted docs in the index); normally
  // you'd use a "normal" query:
  FacetsCollector.search(searcher, new MatchAllDocsQuery(), 10, fc);

  // Retrieve results
  List<FacetResult> results = new ArrayList<>();

  // Count both "Publish Date" and "Author" dimensions
  Facets facets = new FastTaxonomyFacetCounts(taxoReader, config, fc);
  results.add(facets.getTopChildren(10, "Author"));
  results.add(facets.getTopChildren(10, "Publish Date"));
  
  indexReader.close();
  taxoReader.close();
  
  return results;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/** User runs a query and aggregates facets by summing their association values. */
private List<FacetResult> sumAssociations() throws IOException {
  DirectoryReader indexReader = DirectoryReader.open(indexDir);
  IndexSearcher searcher = new IndexSearcher(indexReader);
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);
  
  FacetsCollector fc = new FacetsCollector();
  
  // MatchAllDocsQuery is for "browsing" (counts facets
  // for all non-deleted docs in the index); normally
  // you'd use a "normal" query:
  FacetsCollector.search(searcher, new MatchAllDocsQuery(), 10, fc);
  
  Facets tags = new TaxonomyFacetSumIntAssociations("$tags", taxoReader, config, fc);
  Facets genre = new TaxonomyFacetSumFloatAssociations("$genre", taxoReader, config, fc);

  // Retrieve results
  List<FacetResult> results = new ArrayList<>();
  results.add(tags.getTopChildren(10, "tags"));
  results.add(genre.getTopChildren(10, "genre"));

  indexReader.close();
  taxoReader.close();
  
  return results;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
private void computeChildrenSiblings(int first) {
  // reset the youngest child of all ordinals. while this should be done only
  // for the leaves, we don't know up front which are the leaves, so we reset
  // all of them.
  for (int i = first; i < parents.length; i++) {
    children[i] = TaxonomyReader.INVALID_ORDINAL;
  }
  
  // the root category has no parent, and therefore no siblings
  if (first == 0) {
    first = 1;
    siblings[0] = TaxonomyReader.INVALID_ORDINAL;
  }
  
  for (int i = first; i < parents.length; i++) {
    // note that parents[i] is always < i, so the right-hand-side of
    // the following line is already set when we get here
    siblings[i] = children[parents[i]];
    children[parents[i]] = i;
  }
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/**
 * Add a new category into the index (and the cache), and return its new
 * ordinal.
 * <p>
 * Actually, we might also need to add some of the category's ancestors
 * before we can add the category itself (while keeping the invariant that a
 * parent is always added to the taxonomy before its child). We do this by
 * recursion.
 */
private int internalAddCategory(FacetLabel cp) throws IOException {
  // Find our parent's ordinal (recursively adding the parent category
  // to the taxonomy if it's not already there). Then add the parent
  // ordinal as payloads (rather than a stored field; payloads can be
  // more efficiently read into memory in bulk by LuceneTaxonomyReader)
  int parent;
  if (cp.length > 1) {
    FacetLabel parentPath = cp.subpath(cp.length - 1);
    parent = findCategory(parentPath);
    if (parent < 0) {
      parent = internalAddCategory(parentPath);
    }
  } else if (cp.length == 1) {
    parent = TaxonomyReader.ROOT_ORDINAL;
  } else {
    parent = TaxonomyReader.INVALID_ORDINAL;
  }
  int id = addCategoryDocument(cp, parent);

  return id;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
public void testEmptyIndex() throws Exception {
  // LUCENE-5045: make sure DrillSideways works with an empty index
  Directory dir = newDirectory();
  Directory taxoDir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  DirectoryTaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(taxoDir, IndexWriterConfig.OpenMode.CREATE);
  IndexSearcher searcher = newSearcher(writer.getReader());
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoWriter);

  // Count "Author"
  FacetsConfig config = new FacetsConfig();
  DrillSideways ds = new DrillSideways(searcher, config, taxoReader);
  DrillDownQuery ddq = new DrillDownQuery(config);
  ddq.add("Author", "Lisa");
  
  DrillSidewaysResult r = ds.search(ddq, 10); // this used to fail on IllegalArgEx
  assertEquals(0, r.hits.totalHits);

  r = ds.search(ddq, null, null, 10, new Sort(new SortField("foo", SortField.Type.INT)), false, false); // this used to fail on IllegalArgEx
  assertEquals(0, r.hits.totalHits);
  
  IOUtils.close(writer, taxoWriter, searcher.getIndexReader(), taxoReader, dir, taxoDir);
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
@Test
public void testBackwardsCompatibility() throws Exception {
  // tests that if the taxonomy index doesn't have the INDEX_EPOCH
  // property (supports pre-3.6 indexes), all still works.
  Directory dir = newDirectory();
  
  // create an empty index first, so that DirTaxoWriter initializes indexEpoch to 1.
  new IndexWriter(dir, new IndexWriterConfig(TEST_VERSION_CURRENT, null)).close();
  
  DirectoryTaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(dir, OpenMode.CREATE_OR_APPEND, NO_OP_CACHE);
  taxoWriter.close();
  
  DirectoryTaxonomyReader taxoReader = new DirectoryTaxonomyReader(dir);
  assertEquals(1, Integer.parseInt(taxoReader.getCommitUserData().get(DirectoryTaxonomyWriter.INDEX_EPOCH)));
  assertNull(TaxonomyReader.openIfChanged(taxoReader));
  taxoReader.close();
  
  dir.close();
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
@Test
public void testOpenIfChangedAndRefCount() throws Exception {
  Directory dir = new RAMDirectory(); // no need for random directories here

  DirectoryTaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(dir);
  taxoWriter.addCategory(new FacetLabel("a"));
  taxoWriter.commit();

  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(dir);
  assertEquals("wrong refCount", 1, taxoReader.getRefCount());

  taxoReader.incRef();
  assertEquals("wrong refCount", 2, taxoReader.getRefCount());

  taxoWriter.addCategory(new FacetLabel("a", "b"));
  taxoWriter.commit();
  TaxonomyReader newtr = TaxonomyReader.openIfChanged(taxoReader);
  assertNotNull(newtr);
  taxoReader.close();
  taxoReader = newtr;
  assertEquals("wrong refCount", 1, taxoReader.getRefCount());

  taxoWriter.close();
  taxoReader.close();
  dir.close();
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/** User runs a query and counts facets. */
private List<FacetResult> facetsWithSearch() throws IOException {
    DirectoryReader indexReader = DirectoryReader.open(indexDir);
    IndexSearcher searcher = new IndexSearcher(indexReader);
    TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);

    FacetsCollector fc = new FacetsCollector();

    // MatchAllDocsQuery is for "browsing" (counts facets
    // for all non-deleted docs in the index); normally
    // you'd use a "normal" query:
    FacetsCollector.search(searcher, new MatchAllDocsQuery(), 10, fc);

    // Retrieve results
    List<FacetResult> results = new ArrayList<FacetResult>();

    // Count both "Publish Date" and "Author" dimensions
    Facets facets = new FastTaxonomyFacetCounts(taxoReader, config, fc);
    results.add(facets.getTopChildren(10, "Author"));
    results.add(facets.getTopChildren(10, "Publish Date"));

    indexReader.close();
    taxoReader.close();

    return results;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/** User drills down on 'Publish Date/2010', and we
 *  return facets for both 'Publish Date' and 'Author',
 *  using DrillSideways. */
private List<FacetResult> drillSideways() throws IOException {
    DirectoryReader indexReader = DirectoryReader.open(indexDir);
    IndexSearcher searcher = new IndexSearcher(indexReader);
    TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);

    // Passing no baseQuery means we drill down on all
    // documents ("browse only"):
    DrillDownQuery q = new DrillDownQuery(config);

    // Now user drills down on Publish Date/2010:
    q.add("Publish Date", "2010");

    DrillSideways ds = new DrillSideways(searcher, config, taxoReader);
    DrillSidewaysResult result = ds.search(q, 10);

    // Retrieve results

    List<FacetResult> facets = result.facets.getAllDims(10);

    indexReader.close();
    taxoReader.close();

    return facets;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
/** User drills down on 'Publish date/2010'. */
private List<FacetResult> drillDown() throws IOException {
  DirectoryReader indexReader = DirectoryReader.open(indexDir);
  IndexSearcher searcher = new IndexSearcher(indexReader);
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);

  // Now user drills down on Publish Date/2010:
  FacetSearchParams fsp = new FacetSearchParams(new CountFacetRequest(new CategoryPath("Author"), 10));
  DrillDownQuery q = new DrillDownQuery(fsp.indexingParams, new MatchAllDocsQuery());
  q.add(new CategoryPath("Publish Date/2010", '/'));
  FacetsCollector fc = FacetsCollector.create(fsp, searcher.getIndexReader(), taxoReader);
  searcher.search(q, fc);

  // Retrieve results
  List<FacetResult> facetResults = fc.getFacetResults();
  
  indexReader.close();
  taxoReader.close();
  
  return facetResults;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
static TotalFacetCounts loadFromFile(File inputFile, TaxonomyReader taxonomy, 
    FacetIndexingParams facetIndexingParams) throws IOException {
  DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream(inputFile)));
  try {
    int[][] counts = new int[dis.readInt()][];
    for (int i=0; i<counts.length; i++) {
      int size = dis.readInt();
      if (size<0) {
        counts[i] = null;
      } else {
        counts[i] = new int[size];
        for (int j=0; j<size; j++) {
          counts[i][j] = dis.readInt();
        }
      }
    }
    return new TotalFacetCounts(taxonomy, facetIndexingParams, counts, CreationType.Loaded);
  } finally {
    dis.close();
  }
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
static TotalFacetCounts compute(final IndexReader indexReader, final TaxonomyReader taxonomy, 
    final FacetIndexingParams facetIndexingParams) throws IOException {
  int partitionSize = PartitionsUtils.partitionSize(facetIndexingParams, taxonomy);
  final int[][] counts = new int[(int) Math.ceil(taxonomy.getSize()  /(float) partitionSize)][partitionSize];
  FacetSearchParams newSearchParams = new FacetSearchParams(facetIndexingParams, DUMMY_REQ); 
    //createAllListsSearchParams(facetIndexingParams,  this.totalCounts);
  StandardFacetsAccumulator sfa = new StandardFacetsAccumulator(newSearchParams, indexReader, taxonomy) {
    @Override
    protected HashMap<CategoryListIterator, Aggregator> getCategoryListMap(
        FacetArrays facetArrays, int partition) throws IOException {
      
      Aggregator aggregator = new CountingAggregator(counts[partition]);
      HashMap<CategoryListIterator, Aggregator> map = new HashMap<CategoryListIterator, Aggregator>();
      for (CategoryListParams clp: facetIndexingParams.getAllCategoryListParams()) {
        map.put(clp.createCategoryListIterator(partition), aggregator);
      }
      return map;
    }
  };
  sfa.setComplementThreshold(StandardFacetsAccumulator.DISABLE_COMPLEMENT);
  sfa.accumulate(ScoredDocIdsUtils.createAllDocsScoredDocIDs(indexReader));
  return new TotalFacetCounts(taxonomy, facetIndexingParams, counts, CreationType.Computed);
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
@Override
protected final int addSiblings(int ordinal, int[] siblings, PriorityQueue<FacetResultNode> pq) {
  FacetResultNode top = pq.top();
  int numResults = 0;
  while (ordinal != TaxonomyReader.INVALID_ORDINAL) {
    int value = values[ordinal];
    if (value > top.value) {
      top.value = value;
      top.ordinal = ordinal;
      top = pq.updateTop();
      ++numResults;
    }
    ordinal = siblings[ordinal];
  }
  return numResults;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
@Override
public IntermediateFacetResult fetchPartitionResult(int offset)
throws IOException {
  TopKFacetResult res = null;
  int ordinal = taxonomyReader.getOrdinal(facetRequest.categoryPath);
  if (ordinal != TaxonomyReader.INVALID_ORDINAL) {
    double value = 0;  
    if (isSelfPartition(ordinal, facetArrays, offset)) {
      int partitionSize = facetArrays.arrayLength;
      value = facetRequest.getValueOf(facetArrays, ordinal % partitionSize);
    }
    
    FacetResultNode parentResultNode = new FacetResultNode(ordinal, value);
    
    Heap<FacetResultNode> heap = ResultSortUtils.createSuitableHeap(facetRequest);
    int totalFacets = heapDescendants(ordinal, heap, parentResultNode, offset);
    res = new TopKFacetResult(facetRequest, parentResultNode, totalFacets);
    res.setHeap(heap);
  }
  return res;
}
 

import org.apache.lucene.facet.taxonomy.TaxonomyReader; //导入依赖的package包/类
@Override
protected final int addSiblings(int ordinal, int[] siblings, PriorityQueue<FacetResultNode> pq) {
  FacetResultNode top = pq.top();
  int numResults = 0;
  while (ordinal != TaxonomyReader.INVALID_ORDINAL) {
    float value = values[ordinal];
    if (value > top.value) {
      top.value = value;
      top.ordinal = ordinal;
      top = pq.updateTop();
      ++numResults;
    }
    ordinal = siblings[ordinal];
  }
  return numResults;
}