Java SolrIndexSearcher.getIndexReader方法代码示例

import org.apache.solr.search.SolrIndexSearcher; //导入方法依赖的package包/类
@Override
public void build(SolrCore core, SolrIndexSearcher searcher) throws IOException {
  IndexReader reader = null;
  if (sourceLocation == null) {
    // Load from Solr's index
    reader = searcher.getIndexReader();
  } else {
    // Load from Lucene index at given sourceLocation
    reader = this.reader;
  }

  // Create the dictionary
  dictionary = new HighFrequencyDictionary(reader, field,
      threshold);
  // TODO: maybe whether or not to clear the index should be configurable?
  // an incremental update is faster (just adds new terms), but if you 'expunged'
  // old terms I think they might hang around.
  spellChecker.clearIndex();
  // TODO: you should be able to specify the IWC params?
  // TODO: if we enable this, codec gets angry since field won't exist in the schema
  // config.setCodec(core.getCodec());
  spellChecker.indexDictionary(dictionary, new IndexWriterConfig(core.getSolrConfig().luceneMatchVersion, null), false);
}
 

import org.apache.solr.search.SolrIndexSearcher; //导入方法依赖的package包/类
@Override
public Dictionary create(SolrCore core, SolrIndexSearcher searcher) {
  if(params == null) {
    // should not happen; implies setParams was not called
    throw new IllegalStateException("Value of params not set");
  }
  String field = (String) params.get(FIELD);
  String weightField = (String) params.get(WEIGHT_FIELD);
  String payloadField = (String) params.get(PAYLOAD_FIELD);
  
  if (field == null) {
    throw new IllegalArgumentException(FIELD + " is a mandatory parameter");
  }
  if (weightField == null) {
    throw new IllegalArgumentException(WEIGHT_FIELD + " is a mandatory parameter");
  }
  
  return new DocumentDictionary(searcher.getIndexReader(), field, weightField, payloadField);
}
 

import org.apache.solr.search.SolrIndexSearcher; //导入方法依赖的package包/类
@Override
public Dictionary create(SolrCore core, SolrIndexSearcher searcher) {
  if(params == null) {
    // should not happen; implies setParams was not called
    throw new IllegalStateException("Value of params not set");
  }
  String field = (String)params.get(SolrSpellChecker.FIELD);
  
  if (field == null) {
    throw new IllegalArgumentException(SolrSpellChecker.FIELD + " is a mandatory parameter");
  }
  
  float threshold = params.get(THRESHOLD_TOKEN_FREQUENCY) == null ? 0.0f
      : (Float)params.get(THRESHOLD_TOKEN_FREQUENCY);
  
  return new HighFrequencyDictionary(searcher.getIndexReader(), field, threshold);
}
 

import org.apache.solr.search.SolrIndexSearcher; //导入方法依赖的package包/类
@Override
public Dictionary create(SolrCore core, SolrIndexSearcher searcher) {
  if(params == null) {
    // should not happen; implies setParams was not called
    throw new IllegalStateException("Value of params not set");
  }
  
  String field = (String) params.get(FIELD);
  String payloadField = (String) params.get(PAYLOAD_FIELD);
  String weightExpression = (String) params.get(WEIGHT_EXPRESSION);
  Set<SortField> sortFields = new HashSet<>();
  
  if (field == null) {
    throw new IllegalArgumentException(FIELD + " is a mandatory parameter");
  }
  
  if (weightExpression == null) {
    throw new IllegalArgumentException(WEIGHT_EXPRESSION + " is a mandatory parameter");
  }
  
  for(int i = 0; i < params.size(); i++) {
    if (params.getName(i).equals(SORT_FIELD)) {
      String sortFieldName = (String) params.getVal(i);

      SortField.Type sortFieldType = getSortFieldType(core, sortFieldName);
      
      if (sortFieldType == null) {
        throw new IllegalArgumentException(sortFieldName + " could not be mapped to any appropriate type"
            + " [long, int, float, double]");
      }
      
      SortField sortField = new SortField(sortFieldName, sortFieldType);
      sortFields.add(sortField);
    }
  }
 
  return new DocumentValueSourceDictionary(searcher.getIndexReader(), field, fromExpression(weightExpression,
      sortFields), payloadField);
}
 

import org.apache.solr.search.SolrIndexSearcher; //导入方法依赖的package包/类
static void assertNotNRT(int maxDoc) {
  SolrCore core = h.getCore();
  log.info("Checking notNRT & maxDoc=" + maxDoc + " of core=" + core.toString());
  RefCounted<SolrIndexSearcher> searcher = core.getSearcher();
  try {
    SolrIndexSearcher s = searcher.get();
    DirectoryReader ir = s.getIndexReader();
    assertEquals("SOLR-5815? : wrong maxDoc: core=" + core.toString() +" searcher=" + s.toString(),
                 maxDoc, ir.maxDoc());
    assertFalse("SOLR-5815? : expected non-NRT reader, got: " + ir, ir.toString().contains(":nrt"));
  } finally {
    searcher.decref();
  }
}
 

import org.apache.solr.search.SolrIndexSearcher; //导入方法依赖的package包/类
public void build(SolrCore core, SolrIndexSearcher searcher) throws IOException {
    LOG.info("build()");

    reader = searcher.getIndexReader();
    //dictionary = new HighFrequencyDictionary(reader, field, threshold);

    // first, use class above to get all terms above the frequency
    // then execute a pivot facet
}
 

import org.apache.solr.search.SolrIndexSearcher; //导入方法依赖的package包/类
@Test
public void testSpelling() throws Exception {
  IndexBasedSpellChecker checker = new IndexBasedSpellChecker();

  NamedList spellchecker = new NamedList();
  spellchecker.add("classname", IndexBasedSpellChecker.class.getName());

  File indexDir = createTempDir();

  spellchecker.add(AbstractLuceneSpellChecker.INDEX_DIR, indexDir.getAbsolutePath());
  spellchecker.add(AbstractLuceneSpellChecker.FIELD, "title");
  spellchecker.add(AbstractLuceneSpellChecker.SPELLCHECKER_ARG_NAME, spellchecker);
  SolrCore core = h.getCore();

  String dictName = checker.init(spellchecker, core);
  assertTrue(dictName + " is not equal to " + SolrSpellChecker.DEFAULT_DICTIONARY_NAME,
          dictName.equals(SolrSpellChecker.DEFAULT_DICTIONARY_NAME) == true);
  RefCounted<SolrIndexSearcher> holder = core.getSearcher();
  SolrIndexSearcher searcher = holder.get();
  try {
  checker.build(core, searcher);

  IndexReader reader = searcher.getIndexReader();
  Collection<Token> tokens = queryConverter.convert("documemt");
  SpellingOptions spellOpts = new SpellingOptions(tokens, reader);
  SpellingResult result = checker.getSuggestions(spellOpts);
  assertTrue("result is null and it shouldn't be", result != null);
  //should be lowercased, b/c we are using a lowercasing analyzer
  Map<String, Integer> suggestions = result.get(spellOpts.tokens.iterator().next());
  assertTrue("documemt is null and it shouldn't be", suggestions != null);
  assertTrue("documemt Size: " + suggestions.size() + " is not: " + 1, suggestions.size() == 1);
  Map.Entry<String, Integer> entry = suggestions.entrySet().iterator().next();
  assertTrue(entry.getKey() + " is not equal to " + "document", entry.getKey().equals("document") == true);
  assertTrue(entry.getValue() + " does not equal: " + SpellingResult.NO_FREQUENCY_INFO, entry.getValue() == SpellingResult.NO_FREQUENCY_INFO);

  //test something not in the spell checker
  spellOpts.tokens = queryConverter.convert("super");
  result = checker.getSuggestions(spellOpts);
  assertTrue("result is null and it shouldn't be", result != null);
  suggestions = result.get(spellOpts.tokens.iterator().next());
  assertTrue("suggestions size should be 0", suggestions.size()==0);

  //test something that is spelled correctly
  spellOpts.tokens = queryConverter.convert("document");
  result = checker.getSuggestions(spellOpts);
  assertTrue("result is null and it shouldn't be", result != null);
  suggestions = result.get(spellOpts.tokens.iterator().next());
  assertTrue("suggestions is null and it shouldn't be", suggestions == null);

  //Has multiple possibilities, but the exact exists, so that should be returned
  spellOpts.tokens = queryConverter.convert("red");
  spellOpts.count = 2;
  result = checker.getSuggestions(spellOpts);
  assertNotNull(result);
  suggestions = result.get(spellOpts.tokens.iterator().next());
  assertTrue("suggestions is not null and it should be", suggestions == null);

  //Try out something which should have multiple suggestions
  spellOpts.tokens = queryConverter.convert("bug");
  result = checker.getSuggestions(spellOpts);
  assertNotNull(result);
  suggestions = result.get(spellOpts.tokens.iterator().next());
  assertNotNull(suggestions);
  assertTrue("suggestions Size: " + suggestions.size() + " is not: " + 2, suggestions.size() == 2);

  entry = suggestions.entrySet().iterator().next();
  assertTrue(entry.getKey() + " is equal to " + "bug and it shouldn't be", entry.getKey().equals("bug") == false);
  assertTrue(entry.getValue() + " does not equal: " + SpellingResult.NO_FREQUENCY_INFO, entry.getValue() == SpellingResult.NO_FREQUENCY_INFO);

  entry = suggestions.entrySet().iterator().next();
  assertTrue(entry.getKey() + " is equal to " + "bug and it shouldn't be", entry.getKey().equals("bug") == false);
  assertTrue(entry.getValue() + " does not equal: " + SpellingResult.NO_FREQUENCY_INFO, entry.getValue() == SpellingResult.NO_FREQUENCY_INFO);
  } finally {
    holder.decref();
  }
}
 

import org.apache.solr.search.SolrIndexSearcher; //导入方法依赖的package包/类
@Test
public void testExtendedResults() throws Exception {
  IndexBasedSpellChecker checker = new IndexBasedSpellChecker();
  NamedList spellchecker = new NamedList();
  spellchecker.add("classname", IndexBasedSpellChecker.class.getName());

  File indexDir = createTempDir();
  indexDir.mkdirs();
  spellchecker.add(AbstractLuceneSpellChecker.INDEX_DIR, indexDir.getAbsolutePath());
  spellchecker.add(AbstractLuceneSpellChecker.FIELD, "title");
  spellchecker.add(AbstractLuceneSpellChecker.SPELLCHECKER_ARG_NAME, spellchecker);
  SolrCore core = h.getCore();
  String dictName = checker.init(spellchecker, core);
  assertTrue(dictName + " is not equal to " + SolrSpellChecker.DEFAULT_DICTIONARY_NAME,
          dictName.equals(SolrSpellChecker.DEFAULT_DICTIONARY_NAME) == true);
  RefCounted<SolrIndexSearcher> holder = core.getSearcher();
  SolrIndexSearcher searcher = holder.get();
  try {
  checker.build(core, searcher);

  IndexReader reader = searcher.getIndexReader();
  Collection<Token> tokens = queryConverter.convert("documemt");
  SpellingOptions spellOpts = new SpellingOptions(tokens, reader, 1, SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX, true, 0.5f, null);
  SpellingResult result = checker.getSuggestions(spellOpts);
  assertTrue("result is null and it shouldn't be", result != null);
  //should be lowercased, b/c we are using a lowercasing analyzer
  Map<String, Integer> suggestions = result.get(spellOpts.tokens.iterator().next());
  assertTrue("documemt is null and it shouldn't be", suggestions != null);
  assertTrue("documemt Size: " + suggestions.size() + " is not: " + 1, suggestions.size() == 1);
  Map.Entry<String, Integer> entry = suggestions.entrySet().iterator().next();
  assertTrue(entry.getKey() + " is not equal to " + "document", entry.getKey().equals("document") == true);
  assertTrue(entry.getValue() + " does not equal: " + 2, entry.getValue() == 2);

  //test something not in the spell checker
  spellOpts.tokens = queryConverter.convert("super");
  result = checker.getSuggestions(spellOpts);
  assertTrue("result is null and it shouldn't be", result != null);
  suggestions = result.get(spellOpts.tokens.iterator().next());
  assertTrue("suggestions size should be 0", suggestions.size()==0);

  spellOpts.tokens = queryConverter.convert("document");
  result = checker.getSuggestions(spellOpts);
  assertTrue("result is null and it shouldn't be", result != null);
  suggestions = result.get(spellOpts.tokens.iterator().next());
  assertTrue("suggestions is not null and it should be", suggestions == null);
  } finally {
    holder.decref();
  }
}
 

import org.apache.solr.search.SolrIndexSearcher; //导入方法依赖的package包/类
@Test
public void testAlternateLocation() throws Exception {
  String[] ALT_DOCS = new String[]{
          "jumpin jack flash",
          "Sargent Peppers Lonely Hearts Club Band",
          "Born to Run",
          "Thunder Road",
          "Londons Burning",
          "A Horse with No Name",
          "Sweet Caroline"
  };

  IndexBasedSpellChecker checker = new IndexBasedSpellChecker();
  NamedList spellchecker = new NamedList();
  spellchecker.add("classname", IndexBasedSpellChecker.class.getName());
  
  File tmpDir = createTempDir();
  File indexDir = new File(tmpDir, "spellingIdx");
  //create a standalone index
  File altIndexDir = new File(tmpDir, "alternateIdx" + new Date().getTime());
  Directory dir = newFSDirectory(altIndexDir);
  IndexWriter iw = new IndexWriter(
      dir,
      new IndexWriterConfig(TEST_VERSION_CURRENT, new WhitespaceAnalyzer())
  );
  for (int i = 0; i < ALT_DOCS.length; i++) {
    Document doc = new Document();
    doc.add(new TextField("title", ALT_DOCS[i], Field.Store.YES));
    iw.addDocument(doc);
  }
  iw.forceMerge(1);
  iw.close();
  dir.close();
  indexDir.mkdirs();
  spellchecker.add(AbstractLuceneSpellChecker.INDEX_DIR, indexDir.getAbsolutePath());
  spellchecker.add(AbstractLuceneSpellChecker.LOCATION, altIndexDir.getAbsolutePath());
  spellchecker.add(AbstractLuceneSpellChecker.FIELD, "title");
  spellchecker.add(AbstractLuceneSpellChecker.SPELLCHECKER_ARG_NAME, spellchecker);
  SolrCore core = h.getCore();
  String dictName = checker.init(spellchecker, core);
  assertTrue(dictName + " is not equal to " + SolrSpellChecker.DEFAULT_DICTIONARY_NAME,
          dictName.equals(SolrSpellChecker.DEFAULT_DICTIONARY_NAME) == true);
  RefCounted<SolrIndexSearcher> holder = core.getSearcher();
  SolrIndexSearcher searcher = holder.get();
  try {
  checker.build(core, searcher);

  IndexReader reader = searcher.getIndexReader();
  Collection<Token> tokens = queryConverter.convert("flesh");
  SpellingOptions spellOpts = new SpellingOptions(tokens, reader, 1, SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX, true, 0.5f, null);
  SpellingResult result = checker.getSuggestions(spellOpts);
  assertTrue("result is null and it shouldn't be", result != null);
  //should be lowercased, b/c we are using a lowercasing analyzer
  Map<String, Integer> suggestions = result.get(spellOpts.tokens.iterator().next());
  assertTrue("flesh is null and it shouldn't be", suggestions != null);
  assertTrue("flesh Size: " + suggestions.size() + " is not: " + 1, suggestions.size() == 1);
  Map.Entry<String, Integer> entry = suggestions.entrySet().iterator().next();
  assertTrue(entry.getKey() + " is not equal to " + "flash", entry.getKey().equals("flash") == true);
  assertTrue(entry.getValue() + " does not equal: " + 1, entry.getValue() == 1);

  //test something not in the spell checker
  spellOpts.tokens = queryConverter.convert("super");
  result = checker.getSuggestions(spellOpts);
  assertTrue("result is null and it shouldn't be", result != null);
  suggestions = result.get(spellOpts.tokens.iterator().next());
  assertTrue("suggestions size should be 0", suggestions.size()==0);

  spellOpts.tokens = queryConverter.convert("Caroline");
  result = checker.getSuggestions(spellOpts);
  assertTrue("result is null and it shouldn't be", result != null);
  suggestions = result.get(spellOpts.tokens.iterator().next());
  assertTrue("suggestions is not null and it should be", suggestions == null);
  } finally {
    holder.decref();
  }
}