Java FacetsConfig.setMultiValued方法代码示例

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    LuceneSettings settingsSummary = new LuceneSettings();
    FacetsConfig facetsConfig = settingsSummary.facetsConfig;
    String dimName = "untokenized.ggc:kmc0500par103.uri.byOntology";
    facetsConfig.setHierarchical(dimName, true);
    facetsConfig.setMultiValued(dimName, true);
    facetsConfig.setIndexFieldName(dimName, "$facets_ggc:kmc0500par103.uri.byOntology");

    LuceneSettings settingsHolding = new LuceneSettings();
    LuceneSettings settingsRank = new LuceneSettings();
    settingsRank.similarity = new TermFrequencySimilarity();
    this.luceneSummary = new Lucene("summary", new File("/data/NBC-340-lucene/lucene-summary").toPath(), settingsSummary);
    Lucene luceneHolding = new Lucene("holding", new File("/data/NBC-340-lucene/lucene-holding").toPath(), settingsHolding);
    Lucene luceneRank = new Lucene("rank", new File("/data/NBC-340-lucene/lucene-rank").toPath(), settingsRank);
    this.multiLucene = new MultiLucene(Arrays.asList(luceneSummary, luceneHolding, luceneRank));
}
 

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
/** Empty constructor */
public AssociationsFacetsExample() {
  config = new FacetsConfig();
  config.setMultiValued("tags", true);
  config.setIndexFieldName("tags", "$tags");
  config.setMultiValued("genre", true);
  config.setIndexFieldName("genre", "$genre");
}
 

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
@Override
public void configure(FacetsConfig config) {
  for(int i=0;i<maxDims;i++) {
    config.setHierarchical(Integer.toString(i), true);
    config.setMultiValued(Integer.toString(i), true);
  }
}
 

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
@BeforeClass
public static void beforeClass() throws Exception {
  dir = newDirectory();
  taxoDir = newDirectory();
  // preparations - index, taxonomy, content
  
  TaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(taxoDir);

  // Cannot mix ints & floats in the same indexed field:
  config = new FacetsConfig();
  config.setIndexFieldName("int", "$facets.int");
  config.setMultiValued("int", true);
  config.setIndexFieldName("float", "$facets.float");
  config.setMultiValued("float", true);

  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);

  // index documents, 50% have only 'b' and all have 'a'
  for (int i = 0; i < 110; i++) {
    Document doc = new Document();
    // every 11th document is added empty, this used to cause the association
    // aggregators to go into an infinite loop
    if (i % 11 != 0) {
      doc.add(new IntAssociationFacetField(2, "int", "a"));
      doc.add(new FloatAssociationFacetField(0.5f, "float", "a"));
      if (i % 2 == 0) { // 50
        doc.add(new IntAssociationFacetField(3, "int", "b"));
        doc.add(new FloatAssociationFacetField(0.2f, "float", "b"));
      }
    }
    writer.addDocument(config.build(taxoWriter, doc));
  }
  
  taxoWriter.close();
  reader = writer.getReader();
  writer.close();
  taxoReader = new DirectoryTaxonomyReader(taxoDir);
}
 

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
public void testLabelWithDelimiter() throws Exception {
  Directory dir = newDirectory();
  Directory taxoDir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  DirectoryTaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(taxoDir, IndexWriterConfig.OpenMode.CREATE);

  FacetsConfig config = new FacetsConfig();
  config.setMultiValued("dim", true);

  Document doc = new Document();
  doc.add(newTextField("field", "text", Field.Store.NO));
  doc.add(new FacetField("dim", "test\u001Fone"));
  doc.add(new FacetField("dim", "test\u001Etwo"));
  writer.addDocument(config.build(taxoWriter, doc));

  // NRT open
  IndexSearcher searcher = newSearcher(writer.getReader());

  // NRT open
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoWriter);

  FacetsCollector c = new FacetsCollector();
  searcher.search(new MatchAllDocsQuery(), c);
  
  Facets facets = getTaxonomyFacetCounts(taxoReader, config, c);
  assertEquals(1, facets.getSpecificValue("dim", "test\u001Fone"));
  assertEquals(1, facets.getSpecificValue("dim", "test\u001Etwo"));

  FacetResult result = facets.getTopChildren(10, "dim");
  assertEquals("dim=dim path=[] value=-1 childCount=2\n  test\u001Fone (1)\n  test\u001Etwo (1)\n", result.toString());
  IOUtils.close(writer, taxoWriter, searcher.getIndexReader(), taxoReader, dir, taxoDir);
}
 

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
private static FacetsConfig getConfig() {
  FacetsConfig config = new FacetsConfig();
  config.setMultiValued("A", true);
  config.setMultiValued("B", true);
  config.setRequireDimCount("B", true);
  config.setHierarchical("D", true);
  return config;
}
 

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
public void testBasic() throws Exception {
  assumeTrue("Test requires SortedSetDV support", defaultCodecSupportsSortedSet());
  Directory dir = newDirectory();

  FacetsConfig config = new FacetsConfig();
  config.setMultiValued("a", true);
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);

  Document doc = new Document();
  doc.add(new SortedSetDocValuesFacetField("a", "foo"));
  doc.add(new SortedSetDocValuesFacetField("a", "bar"));
  doc.add(new SortedSetDocValuesFacetField("a", "zoo"));
  doc.add(new SortedSetDocValuesFacetField("b", "baz"));
  writer.addDocument(config.build(doc));
  if (random().nextBoolean()) {
    writer.commit();
  }

  doc = new Document();
  doc.add(new SortedSetDocValuesFacetField("a", "foo"));
  writer.addDocument(config.build(doc));

  // NRT open
  IndexSearcher searcher = newSearcher(writer.getReader());

  // Per-top-reader state:
  SortedSetDocValuesReaderState state = new DefaultSortedSetDocValuesReaderState(searcher.getIndexReader());
  
  FacetsCollector c = new FacetsCollector();

  searcher.search(new MatchAllDocsQuery(), c);

  SortedSetDocValuesFacetCounts facets = new SortedSetDocValuesFacetCounts(state, c);

  assertEquals("dim=a path=[] value=4 childCount=3\n  foo (2)\n  bar (1)\n  zoo (1)\n", facets.getTopChildren(10, "a").toString());
  assertEquals("dim=b path=[] value=1 childCount=1\n  baz (1)\n", facets.getTopChildren(10, "b").toString());

  // DrillDown:
  DrillDownQuery q = new DrillDownQuery(config);
  q.add("a", "foo");
  q.add("b", "baz");
  TopDocs hits = searcher.search(q, 1);
  assertEquals(1, hits.totalHits);

  IOUtils.close(writer, searcher.getIndexReader(), dir);
}
 

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
public void testMultiValuedHierarchy() throws Exception {
  Directory dir = newDirectory();
  Directory taxoDir = newDirectory();
  DirectoryTaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(taxoDir, IndexWriterConfig.OpenMode.CREATE);
  FacetsConfig config = new FacetsConfig();
  config.setHierarchical("a", true);
  config.setMultiValued("a", true);
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);

  Document doc = new Document();
  doc.add(newTextField("field", "text", Field.Store.NO));
  doc.add(new FacetField("a", "path", "x"));
  doc.add(new FacetField("a", "path", "y"));
  writer.addDocument(config.build(taxoWriter, doc));

  // NRT open
  IndexSearcher searcher = newSearcher(writer.getReader());

  // NRT open
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoWriter);
  
  // Aggregate the facet counts:
  FacetsCollector c = new FacetsCollector();

  // MatchAllDocsQuery is for "browsing" (counts facets
  // for all non-deleted docs in the index); normally
  // you'd use a "normal" query, and use MultiCollector to
  // wrap collecting the "normal" hits and also facets:
  searcher.search(new MatchAllDocsQuery(), c);
  Facets facets = getTaxonomyFacetCounts(taxoReader, config, c);

  try {
    facets.getSpecificValue("a");
    fail("didn't hit expected exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }

  FacetResult result = facets.getTopChildren(10, "a");
  assertEquals(1, result.labelValues.length);
  assertEquals(1, result.labelValues[0].value.intValue());

  IOUtils.close(writer, taxoWriter, searcher.getIndexReader(), taxoReader, dir, taxoDir);
}
 

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
public void testRequireDimCount() throws Exception {
  Directory dir = newDirectory();
  Directory taxoDir = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir);
  DirectoryTaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(taxoDir, IndexWriterConfig.OpenMode.CREATE);

  FacetsConfig config = new FacetsConfig();
  config.setRequireDimCount("dim", true);

  config.setMultiValued("dim2", true);
  config.setRequireDimCount("dim2", true);

  config.setMultiValued("dim3", true);
  config.setHierarchical("dim3", true);
  config.setRequireDimCount("dim3", true);

  Document doc = new Document();
  doc.add(newTextField("field", "text", Field.Store.NO));
  doc.add(new FacetField("dim", "a"));
  doc.add(new FacetField("dim2", "a"));
  doc.add(new FacetField("dim2", "b"));
  doc.add(new FacetField("dim3", "a", "b"));
  doc.add(new FacetField("dim3", "a", "c"));
  writer.addDocument(config.build(taxoWriter, doc));

  // NRT open
  IndexSearcher searcher = newSearcher(writer.getReader());

  // NRT open
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoWriter);

  FacetsCollector c = new FacetsCollector();
  searcher.search(new MatchAllDocsQuery(), c);
  
  Facets facets = getTaxonomyFacetCounts(taxoReader, config, c);
  assertEquals(1, facets.getTopChildren(10, "dim").value);
  assertEquals(1, facets.getTopChildren(10, "dim2").value);
  assertEquals(1, facets.getTopChildren(10, "dim3").value);
  try {
    assertEquals(1, facets.getSpecificValue("dim"));
    fail("didn't hit expected exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }
  assertEquals(1, facets.getSpecificValue("dim2"));
  assertEquals(1, facets.getSpecificValue("dim3"));
  IOUtils.close(writer, taxoWriter, searcher.getIndexReader(), taxoReader, dir, taxoDir);
}
 

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
public void testManyFacetsInOneDocument() throws Exception {
  assumeTrue("default Codec doesn't support huge BinaryDocValues", TestUtil.fieldSupportsHugeBinaryDocValues(FacetsConfig.DEFAULT_INDEX_FIELD_NAME));
  Directory dir = newDirectory();
  Directory taxoDir = newDirectory();
  IndexWriterConfig iwc = newIndexWriterConfig(new MockAnalyzer(random()));
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir, iwc);
  DirectoryTaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(taxoDir, IndexWriterConfig.OpenMode.CREATE);

  FacetsConfig config = new FacetsConfig();
  config.setMultiValued("dim", true);
  
  int numLabels = TestUtil.nextInt(random(), 40000, 100000);
  
  Document doc = new Document();
  doc.add(newTextField("field", "text", Field.Store.NO));
  for (int i = 0; i < numLabels; i++) {
    doc.add(new FacetField("dim", "" + i));
  }
  writer.addDocument(config.build(taxoWriter, doc));
  
  // NRT open
  IndexSearcher searcher = newSearcher(writer.getReader());
  
  // NRT open
  TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoWriter);
  
  // Aggregate the facet counts:
  FacetsCollector c = new FacetsCollector();
  
  // MatchAllDocsQuery is for "browsing" (counts facets
  // for all non-deleted docs in the index); normally
  // you'd use a "normal" query, and use MultiCollector to
  // wrap collecting the "normal" hits and also facets:
  searcher.search(new MatchAllDocsQuery(), c);
  Facets facets = getTaxonomyFacetCounts(taxoReader, config, c);

  FacetResult result = facets.getTopChildren(Integer.MAX_VALUE, "dim");
  assertEquals(numLabels, result.labelValues.length);
  Set<String> allLabels = new HashSet<>();
  for (LabelAndValue labelValue : result.labelValues) {
    allLabels.add(labelValue.label);
    assertEquals(1, labelValue.value.intValue());
  }
  assertEquals(numLabels, allLabels.size());
  
  IOUtils.close(searcher.getIndexReader(), taxoWriter, writer, taxoReader, dir, taxoDir);
}
 

import org.apache.lucene.facet.FacetsConfig; //导入方法依赖的package包/类
public void testDirectory() throws Exception {
  Directory indexDir = newDirectory();
  Directory taxoDir = newDirectory();
  final IndexWriter w = new IndexWriter(indexDir, newIndexWriterConfig(new MockAnalyzer(random())));
  final DirectoryTaxonomyWriter tw = new DirectoryTaxonomyWriter(taxoDir);
  // first empty commit
  w.commit();
  tw.commit();
  final SearcherTaxonomyManager mgr = new SearcherTaxonomyManager(indexDir, taxoDir, null);
  final FacetsConfig config = new FacetsConfig();
  config.setMultiValued("field", true);
  final AtomicBoolean stop = new AtomicBoolean();

  // How many unique facets to index before stopping:
  final int ordLimit = TEST_NIGHTLY ? 100000 : 6000;

  Thread indexer = new IndexerThread(w, config, tw, mgr, ordLimit, stop);
  indexer.start();

  try {
    while (!stop.get()) {
      SearcherAndTaxonomy pair = mgr.acquire();
      try {
        //System.out.println("search maxOrd=" + pair.taxonomyReader.getSize());
        FacetsCollector sfc = new FacetsCollector();
        pair.searcher.search(new MatchAllDocsQuery(), sfc);
        Facets facets = getTaxonomyFacetCounts(pair.taxonomyReader, config, sfc);
        FacetResult result = facets.getTopChildren(10, "field");
        if (pair.searcher.getIndexReader().numDocs() > 0) { 
          //System.out.println(pair.taxonomyReader.getSize());
          assertTrue(result.childCount > 0);
          assertTrue(result.labelValues.length > 0);
        }

        //if (VERBOSE) {
        //System.out.println("TEST: facets=" + FacetTestUtils.toString(results.get(0)));
        //}
      } finally {
        mgr.release(pair);
      }
    }
  } finally {
    indexer.join();
  }

  if (VERBOSE) {
    System.out.println("TEST: now stop");
  }

  IOUtils.close(mgr, tw, w, taxoDir, indexDir);
}