Java RefCounted.get方法代码示例

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
public Long getVersionFromIndex(BytesRef idBytes) {
  // TODO: we could cache much of this and invalidate during a commit.
  // TODO: most DocValues classes are threadsafe - expose which.

  RefCounted<SolrIndexSearcher> newestSearcher = ulog.uhandler.core.getRealtimeSearcher();
  try {
    SolrIndexSearcher searcher = newestSearcher.get();
    long lookup = searcher.lookupId(idBytes);
    if (lookup < 0) return null;

    ValueSource vs = versionField.getType().getValueSource(versionField, null);
    Map context = ValueSource.newContext(searcher);
    vs.createWeight(context, searcher);
    FunctionValues fv = vs.getValues(context, searcher.getTopReaderContext().leaves().get((int)(lookup>>32)));
    long ver = fv.longVal((int)lookup);
    return ver;

  } catch (IOException e) {
    throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Error reading version from index", e);
  } finally {
    if (newestSearcher != null) {
      newestSearcher.decref();
    }
  }
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
/** Add a document execute the deletes as atomically as possible */
private void addAndDelete(AddUpdateCommand cmd, List<Query> dbqList)
    throws IOException {
  Document luceneDocument = cmd.getLuceneDocument();
  Term idTerm = new Term(idField.getName(), cmd.getIndexedId());
  
  // see comment in deleteByQuery
  synchronized (solrCoreState.getUpdateLock()) {
    RefCounted<IndexWriter> iw = solrCoreState.getIndexWriter(core);
    try {
      IndexWriter writer = iw.get();
      writer.updateDocument(idTerm, luceneDocument, cmd.getReq().getSchema()
          .getIndexAnalyzer());
      
      for (Query q : dbqList) {
        writer.deleteDocuments(q);
      }
    } finally {
      iw.decref();
    }
    
    if (ulog != null) ulog.add(cmd, true);
  }
  
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
boolean waitForNewSearcher(int timeout) {
  long timeoutTime = System.currentTimeMillis() + timeout;
  while (System.currentTimeMillis() < timeoutTime) {
    if (triggered) {
      // check if the new searcher has been registered yet
      RefCounted<SolrIndexSearcher> registeredSearcherH = newSearcher.getCore().getSearcher();
      SolrIndexSearcher registeredSearcher = registeredSearcherH.get();
      registeredSearcherH.decref();
      if (registeredSearcher == newSearcher) return true;
      // log.info("TEST: waiting for searcher " + newSearcher + " to be registered.  current=" + registeredSearcher);
    }

    try {
      Thread.sleep(250);
    } catch (InterruptedException e) {}

  }
  return false;
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
public void testDocValues() throws IOException {
  assertU(adoc("id", "1", "floatdv", "4.5", "intdv", "-1", "intdv", "3", "stringdv", "value1", "stringdv", "value2"));
  assertU(commit());
  try (SolrCore core = h.getCoreInc()) {
    final RefCounted<SolrIndexSearcher> searcherRef = core.openNewSearcher(true, true);
    final SolrIndexSearcher searcher = searcherRef.get();
    try {
      final AtomicReader reader = searcher.getAtomicReader();
      assertEquals(1, reader.numDocs());
      final FieldInfos infos = reader.getFieldInfos();
      assertEquals(DocValuesType.SORTED_SET, infos.fieldInfo("stringdv").getDocValuesType());
      assertEquals(DocValuesType.SORTED_SET, infos.fieldInfo("floatdv").getDocValuesType());
      assertEquals(DocValuesType.SORTED_SET, infos.fieldInfo("intdv").getDocValuesType());

      SortedSetDocValues dv = reader.getSortedSetDocValues("stringdv");
      dv.setDocument(0);
      assertEquals(0, dv.nextOrd());
      assertEquals(1, dv.nextOrd());
      assertEquals(SortedSetDocValues.NO_MORE_ORDS, dv.nextOrd());
    } finally {
      searcherRef.decref();
    }
  }
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
/** Add a document execute the deletes as atomically as possible */
private void addAndDelete(AddUpdateCommand cmd, List<Query> dbqList)
    throws IOException {
  Document luceneDocument = cmd.getLuceneDocument();
  Term idTerm = new Term(idField.getName(), cmd.getIndexedId());
  
  // see comment in deleteByQuery
  synchronized (solrCoreState.getUpdateLock()) {
    RefCounted<IndexWriter> iw = solrCoreState.getIndexWriter(core);
    try {
      IndexWriter writer = iw.get();
      writer.updateDocument(idTerm, luceneDocument, core.getSchema()
          .getAnalyzer());
      
      for (Query q : dbqList) {
        writer.deleteDocuments(q);
      }
    } finally {
      iw.decref();
    }
    
    if (ulog != null) ulog.add(cmd, true);
  }
  
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
@Override
public void deleteByNodeId(Long nodeId) throws IOException
{
    RefCounted<SolrIndexSearcher> refCounted = null;
    try
    {
        refCounted = core.getSearcher(false, true, null);
        SolrIndexSearcher solrIndexSearcher = refCounted.get();

        Query query = new TermQuery(new Term(QueryConstants.FIELD_DBID, NumericEncoder.encode(nodeId)));
        deleteByQuery(solrIndexSearcher, query);
    }
    finally
    {
        if (refCounted != null)
        {
            refCounted.decref();
        }
    }
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
@Override
public void deleteByAclChangeSetId(Long aclChangeSetId) throws IOException
{
    RefCounted<SolrIndexSearcher> refCounted = null;
    try
    {
        refCounted = core.getSearcher(false, true, null);
        SolrIndexSearcher solrIndexSearcher = refCounted.get();

        Query query = new TermQuery(new Term(QueryConstants.FIELD_INACLTXID, NumericEncoder.encode(aclChangeSetId)));
        deleteByQuery(solrIndexSearcher, query);
    }
    finally
    {
        if (refCounted != null)
        {
            refCounted.decref();
        }
    }
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
private List<NamedList<Object>> checkEngine(CarrotClusteringEngine engine, int expectedNumDocs,
                         int expectedNumClusters, Query query, SolrParams clusteringParams) throws IOException {
  // Get all documents to cluster
  RefCounted<SolrIndexSearcher> ref = h.getCore().getSearcher();

  DocList docList;
  try {
    SolrIndexSearcher searcher = ref.get();
    docList = searcher.getDocList(query, (Query) null, new Sort(), 0,
            numberOfDocs);
    assertEquals("docList size", expectedNumDocs, docList.matches());

    ModifiableSolrParams solrParams = new ModifiableSolrParams();
    solrParams.add(clusteringParams);

    // Perform clustering
    LocalSolrQueryRequest req = new LocalSolrQueryRequest(h.getCore(), solrParams);
    Map<SolrDocument,Integer> docIds = new HashMap<>(docList.size());
    SolrDocumentList solrDocList = SolrPluginUtils.docListToSolrDocumentList( docList, searcher, engine.getFieldsToLoad(req), docIds );

    @SuppressWarnings("unchecked")
    List<NamedList<Object>> results = (List<NamedList<Object>>) engine.cluster(query, solrDocList, docIds, req);
    req.close();
    assertEquals("number of clusters: " + results, expectedNumClusters, results.size());
    checkClusters(results, false);
    return results;
  } finally {
    ref.decref();
  }
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
public static SolrInputDocument getInputDocument(SolrCore core, BytesRef idBytes) throws IOException {
  SolrInputDocument sid = null;
  RefCounted<SolrIndexSearcher> searcherHolder = null;
  try {
    SolrIndexSearcher searcher = null;
    sid = getInputDocumentFromTlog(core, idBytes);
    if (sid == DELETED) {
      return null;
    }

    if (sid == null) {
      // didn't find it in the update log, so it should be in the newest searcher opened
      if (searcher == null) {
        searcherHolder = core.getRealtimeSearcher();
        searcher = searcherHolder.get();
      }

      // SolrCore.verbose("RealTimeGet using searcher ", searcher);
      SchemaField idField = core.getLatestSchema().getUniqueKeyField();

      int docid = searcher.getFirstMatch(new Term(idField.getName(), idBytes));
      if (docid < 0) return null;
      Document luceneDocument = searcher.doc(docid);
      sid = toSolrInputDocument(luceneDocument, core.getLatestSchema());
    }
  } finally {
    if (searcherHolder != null) {
      searcherHolder.decref();
    }
  }

  return sid;
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
private Future<RecoveryInfo> replay(SolrCore core)
    throws InterruptedException, ExecutionException {
  Future<RecoveryInfo> future = core.getUpdateHandler().getUpdateLog().applyBufferedUpdates();
  if (future == null) {
    // no replay needed\
    log.info("No replay needed. core=" + coreName);
  } else {
    log.info("Replaying buffered documents. core=" + coreName);
    // wait for replay
    RecoveryInfo report = future.get();
    if (report.failed) {
      SolrException.log(log, "Replay failed");
      throw new SolrException(ErrorCode.SERVER_ERROR, "Replay failed");
    }
  }
  
  // solrcloud_debug
  if (log.isDebugEnabled()) {
    try {
      RefCounted<SolrIndexSearcher> searchHolder = core
          .getNewestSearcher(false);
      SolrIndexSearcher searcher = searchHolder.get();
      try {
        log.debug(core.getCoreDescriptor().getCoreContainer()
            .getZkController().getNodeName()
            + " replayed "
            + searcher.search(new MatchAllDocsQuery(), 1).totalHits);
      } finally {
        searchHolder.decref();
      }
    } catch (Exception e) {
      throw new SolrException(ErrorCode.SERVER_ERROR, null, e);
    }
  }
  
  return future;
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
private int getNumberOfReaders() {
  RefCounted<SolrIndexSearcher> searcherRef = h.getCore().getSearcher();
  try {
    SolrIndexSearcher searcher = searcherRef.get();
    return searcher.getTopReaderContext().leaves().size();
  } finally {
    searcherRef.decref();
  }
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
@Test
public void testAlternateDistance() throws Exception {
  TestSpellChecker checker = new TestSpellChecker();
  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);
  spellchecker.add(AbstractLuceneSpellChecker.STRING_DISTANCE, JaroWinklerDistance.class.getName());
  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);
  SpellChecker sc = checker.getSpellChecker();
  assertTrue("sc is null and it shouldn't be", sc != null);
  StringDistance sd = sc.getStringDistance();
  assertTrue("sd is null and it shouldn't be", sd != null);
  assertTrue("sd is not an instance of " + JaroWinklerDistance.class.getName(), sd instanceof JaroWinklerDistance);
  } finally {
    holder.decref();
  }
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的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.util.RefCounted; //导入方法依赖的package包/类
@Test
public void testTermIndexInterval() throws Exception {
  RefCounted<IndexWriter> iw = ((DirectUpdateHandler2) h.getCore()
      .getUpdateHandler()).getSolrCoreState().getIndexWriter(h.getCore());
  int interval = 0;
  try {
    IndexWriter writer = iw.get();
    interval = writer.getConfig().getTermIndexInterval();
  } finally {
    iw.decref();
  }
  assertEquals(256, interval);
}
 

import org.apache.solr.util.RefCounted; //导入方法依赖的package包/类
private void updateDocValues(String keyField, String[] valueFields, AddUpdateCommand cmd) throws IOException {
  RefCounted<IndexWriter> iwref = core.getSolrCoreState().getIndexWriter(core);
  try {
    IndexWriter iw = iwref.get();
    SolrInputDocument solrInputDocument = cmd.getSolrInputDocument();
    updateDocValuesHelper(keyField, valueFields, iw, solrInputDocument);
  } finally {
    iwref.decref();
  }
}