Java UpdateResponse类代码示例

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
private void persistToSolr(Collection<SolrInputDocument> docs) throws SolrServerException, IOException {
    if (docs.isEmpty()) {
        /**
         * @todo Throw an exception here? "DvObject id 9999 does not exist."
         */
        logger.info("nothing to persist");
        return;
    }
    logger.fine("persisting to Solr...");
    SolrServer solrServer = new HttpSolrServer("http://" + systemConfig.getSolrHostColonPort() + "/solr");
    /**
     * @todo Do something with these responses from Solr.
     */
    UpdateResponse addResponse = solrServer.add(docs);
    UpdateResponse commitResponse = solrServer.commit();
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
public void indexMap(String id, Map<String, List<String>> objectMap)
   throws IOException, SolrServerException {
    SolrInputDocument document = new SolrInputDocument();
    document.addField("id", id);
    for (String key : objectMap.keySet()) {
        Object value = objectMap.get(key);
        if (value != null) {
            // System.err.printf("%s: class: %s\n", key, value.getClass());
            document.addField(key + "_ss", value);
        }
    }

    try {
        UpdateResponse response = solr.add(document);
        // solr.commit();
    } catch (HttpSolrClient.RemoteSolrException ex) {
        System.err.printf("document: %s", document);
        System.err.printf("Commit exception: %s\n", ex.getMessage());
    }
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
public void indexDuplumKey(String id, Map<String, Object> objectMap)
        throws IOException, SolrServerException {
    SolrInputDocument document = new SolrInputDocument();
    document.addField("id", id);
    for (String key : objectMap.keySet()) {
        Object value = objectMap.get(key);
        if (value != null) {
            // System.err.printf("%s: class: %s\n", key, value.getClass());
            document.addField(key + "_ss", value);
        }
    }

    try {
        UpdateResponse response = solr.add(document);
        // solr.commit();
    } catch (HttpSolrClient.RemoteSolrException ex) {
        System.err.printf("document: %s", document);
        System.err.printf("Commit exception: %s\n", ex.getMessage());
    }
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
@Override
public synchronized void deleteIndex(BaseSearchBean bean) throws Exception {
    if (bean == null) {
        logger.warn("Get search bean is empty!");
        return;
    }

    String id = bean.getId();

    if (StringUtils.isEmpty(id)) {
        logger.warn("get id and id value from bean is empty!");
        return;
    }

    UpdateResponse response = solrClient.deleteById(id);
    solrClient.commit();

    if (logger.isDebugEnabled()) {
        logger.debug(String.format("delete id '%s', result: '%d' Qtime: '%d'", id, response.getStatus(), response.getQTime()));
    }
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
private void updateDocs( List<SolrInputDocument> docs, boolean commit ) throws SolrServerException, IOException {
  LOG.debug( "updateDocs " + docs.size( ) );
  SolrClient suggestClient = getSuggestClient( );
  try {
    UpdateResponse resp = suggestClient.add( suggesterCollection, docs );
  }
  catch ( SolrServerException sse ) {
    LOG.error( "Got SolrServerExeption " + sse );
    throw sse;
  }
    
  if (commit) {
    LOG.debug( "committing to " + suggestHost );
    suggestClient.commit( suggesterCollection );
  }
  // check resp - if not OK, throw an Exception??
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
void examineFile(File file) throws FitsException, IOException, SolrServerException, XMLStreamException {
    System.out.println("Adding " + file.getName());
    FitsOutput fitsOutput = fits.examine(file);
    fitsOutput.addStandardCombinedFormat();

    SolrInputDocument solrDoc = new SolrInputDocument();

    this.indexFitsFileInfo(fitsOutput, solrDoc);
    this.indexFitsIdentities(fitsOutput, solrDoc);
    this.indexTechMetadata(fitsOutput, solrDoc);

    Document fitsXml = fitsOutput.getFitsXml();
    this.indexFitsXml(fitsXml, solrDoc);

    try {
        UpdateResponse response = solr.add(solrDoc);
        solr.commit();
    } catch (HttpSolrClient.RemoteSolrException e) {
        e.printStackTrace();
    }

}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
@Override
    public void addItemsToIndex(SolrSimilarityConfigurationInt configuration) throws Exception {
        List<Item> items = solrItemDAO.getNonUserItems(configuration);
        // TODO: implement changeDate on items correctly! index from lastRun!!
        for (Item item : items) {
            SolrInputDocument doc = new SolrInputDocument();
            doc.addField("id", item.getTenantId() + item.getItemType() + item.getItemId());
            doc.addField("tenant_i", item.getTenantId());
            doc.addField("type_i", itemTypeDAO.getIdOfType(item.getTenantId(),item.getItemType()));
            doc.addField("id_i", idMappingDAO.lookupOnly(item.getItemId()));
            String all = "";
            Object parsedProfile = configuration.getConfiguration().jsonProvider().parse(item.getProfileData());
            for ( JsonPath jp : configuration.getIndexFields()) {
                all += addFieldToSolrString(jp, parsedProfile);
            }
            doc.addField("all", all);

            UpdateResponse response = solrClient.add(doc);
        }
        
//        logger.info("Response status:" + response.getStatus());
        
        solrClient.commit();
    }
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
private void write(final EmbeddedDocument child, final int level, final Document parent, final Document root)
		throws IOException {
	final SolrInputDocument inputDocument = prepareDocument(child, level, parent, root);
	final UpdateResponse response;

	// Free up memory.
	child.clearReader();

	// Null is a signal to skip.
	if (null == inputDocument) {
		return;
	}

	response = write(child, inputDocument);
	logger.info("Child document added to Solr in {}ms: \"{}\".", response.getElapsedTime(), child);

	for (EmbeddedDocument grandchild : child.getEmbeds()) {
		write(grandchild, level + 1, child, root);
	}
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
/**
 * Adds the beans supplied by the given iterator.
 * 
 * @param beanIterator
 *          the iterator which returns Beans
 * 
 * @return the response from the SolrServer
 */
public UpdateResponse addBeans(final Iterator<?> beanIterator)
    throws SolrServerException, IOException {
  UpdateRequest req = new UpdateRequest();
  req.setDocIterator(new Iterator<SolrInputDocument>() {
    
    @Override
    public boolean hasNext() {
      return beanIterator.hasNext();
    }
    
    @Override
    public SolrInputDocument next() {
      Object o = beanIterator.next();
      if (o == null) return null;
      return getBinder().toSolrInputDocument(o);
    }
    
    @Override
    public void remove() {
      beanIterator.remove();
    }
  });
  return req.process(this);
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
protected UpdateResponse runUpdate(List<SolrInputDocument> batchToWrite) {
  try {
    UpdateResponse result = solr.add(batchToWrite);
    SolrRecordWriter.incrementCounter(taskId, SolrCounters.class.getName(), SolrCounters.BATCHES_WRITTEN.toString(), 1);      
    SolrRecordWriter.incrementCounter(taskId, SolrCounters.class.getName(), SolrCounters.DOCUMENTS_WRITTEN.toString(), batchToWrite.size());
    if (LOG.isDebugEnabled()) {
      SolrRecordWriter.incrementCounter(taskId, SolrCounters.class.getName(), SolrCounters.BATCH_WRITE_TIME.toString(), result.getElapsedTime());
    }
    return result;
  } catch (Throwable e) {
    if (e instanceof Exception) {
      setBatchWriteException((Exception) e);
    } else {
      setBatchWriteException(new Exception(e));
    }
    SolrRecordWriter.incrementCounter(taskId, getClass().getName() + ".errors", e.getClass().getName(), 1);
    LOG.error("Unable to process batch", e);
    return null;
  }
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
private void performUpdate(Delete obj) throws TranslatorException {
	Table table = obj.getTable().getMetadataObject();
	KeyRecord pk = table.getPrimaryKey();
	final String id = getRecordName(pk.getColumns().get(0));

	if (obj.getParameterValues() != null) {
		throw new TranslatorException(SolrPlugin.Event.TEIID20008, SolrPlugin.Util.gs(SolrPlugin.Event.TEIID20008));
	}
	
	SolrQueryExecution query = new SolrQueryExecution(ef, obj, this.executionContext, this.metadata, this.connection);
	query.execute();
	
	final UpdateRequest request = new UpdateRequest();
	query.walkDocuments(new SolrDocumentCallback() {
		@Override
		public void walk(SolrDocument doc) {
			SolrUpdateExecution.this.updateCount++;
			request.deleteById(doc.getFieldValue(id).toString());
		}
	});
	
	UpdateResponse response = this.connection.update(request);
	if (response.getStatus() != 0) {
		throw new TranslatorException(SolrPlugin.Event.TEIID20005, SolrPlugin.Util.gs(SolrPlugin.Event.TEIID20005, response.getStatus()));
	}		
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
/**
 * @param doc
 * @return Error message, if occurred; null otherwise.
 * @throws FatalIndexerException
 * @should write doc correctly
 */
public boolean writeToIndex(SolrInputDocument doc) throws FatalIndexerException {
    boolean success = false;
    int tries = RETRY_ATTEMPTS;

    while (!success && tries > 0) {
        tries--;
        try {
            UpdateResponse ur = server.add(doc);
            switch (ur.getStatus()) {
                case 0:
                    success = true;
                    break;
                default:
                    logger.error("Update status: {}", ur.getStatus());
            }
            return true;
        } catch (SolrServerException | IOException e) {
            logger.error(e.getMessage(), e);
        }
    }

    if (!success) {
        logger.error("Could not write document after {} attempts. Check the Solr server connection. Exiting...", RETRY_ATTEMPTS);
        rollback();
        throw new FatalIndexerException("Solr connection error");
    }

    return false;
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
/**
 * Write a document using the SolrTemplate
 */
@Test
@SuppressWarnings("unchecked")
public void simpleWrite() throws Exception {
    DiscoSolrDocument doc = discoDocument("1", "simpleWriteWithTemplate");

    // NOT TRUE WITH spring-data-solr 3: Don't need to use the saveBean(core, doc) method, because the document has the core as an annotation
    UpdateResponse res = solrTemplate.saveBean("discos", doc);
    assertNotNull(res);

    solrTemplate.commit("discos");
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
@Test
public void writeAndUpdateDiscoDocUsingPartialUpdate() throws Exception {
    String solrCore = "discos";
    long expectedDocId = 200L;
    DiscoSolrDocument doc = new DiscoSolrDocument.Builder()
            .docId(String.valueOf(expectedDocId))
            .discoUri("http://doi.org/10.1109/disco/2")
            .discoStatus("ACTIVE")
            .build();

    UpdateResponse res = solrTemplate.saveBean(solrCore, doc);
    assertNotNull(res);
    assertEquals(0, res.getStatus());
    solrTemplate.commit(solrCore);


    assertEquals(doc, solrTemplate.getById(solrCore, expectedDocId, DiscoSolrDocument.class)
            .orElseThrow(() -> new RuntimeException(
                    "Expected to find a DiscoSolrDocument with ID " + doc.getDocId() + " in the index.")));

    // Update using Solr Atomic Updates (requires <updateLog/>)
    PartialUpdate update = new PartialUpdate(DiscoSolrDocument.DOC_ID, doc.getDocId());
    update.setValueOfField(DiscoSolrDocument.DISCO_STATUS, "INACTIVE");
    res = solrTemplate.saveBean(solrCore, update);
    assertNotNull(res);
    assertEquals(0, res.getStatus());
    solrTemplate.commit(solrCore);

    assertEquals("INACTIVE", solrTemplate.getById(solrCore, expectedDocId, DiscoSolrDocument.class)
            .orElseThrow(() -> new RuntimeException(
                    "Expected to find a DiscoSolrDocument with ID " + doc.getDocId() + " in the index."))
            .getDiscoStatus());
}
 

import org.apache.solr.client.solrj.response.UpdateResponse; //导入依赖的package包/类
@Override
public void index() throws IOException, SolrServerException {
    LOGGER.info("Sending optimize request to solr");
    UpdateResponse response = getSolrClient().optimize();
    LOGGER.info(MessageFormat.format("Optimize was {0}({1}ms)",
        (response.getStatus() == 0 ? "successful." : "UNSUCCESSFUL!"), response.getElapsedTime()));
}