Java DeleteUpdateCommand.setQuery方法代码示例

import org.apache.solr.update.DeleteUpdateCommand; //导入方法依赖的package包/类
private void deleteByQuery(String query) throws IOException
{
    SolrQueryRequest request = null;
    UpdateRequestProcessor processor = null;
    try
    {
        request = getLocalSolrQueryRequest();
        processor = this.core.getUpdateProcessingChain(null).createProcessor(request, new SolrQueryResponse());
        DeleteUpdateCommand delDocCmd = new DeleteUpdateCommand(request);
        delDocCmd.setQuery(query);
        processor.processDelete(delDocCmd);
    }
    finally
    {
        if(processor != null) {processor.finish();}
        if(request != null) {request.close();}
    }
}
 

import org.apache.solr.update.DeleteUpdateCommand; //导入方法依赖的package包/类
/**
 * Deletes documents identified by the given documents.
 *
 * @param docs the documents
 * @throws IOException iff something goes wrong
 */
public void delete(Collection<Document> docs) throws IOException {
    DeleteUpdateCommand cmd = new DeleteUpdateCommand(req);
    cmd.commitWithin = COMMIT_WITHIN;
    cmd.setFlags(DeleteUpdateCommand.BUFFERING);
    cmd.setQuery("{!terms f=" + ID + "}" + docs.stream().map(it -> it.get(ID)).collect(joining(",")));
    updateProcessor.processDelete(cmd);
}
 

import org.apache.solr.update.DeleteUpdateCommand; //导入方法依赖的package包/类
private void verifyAuthorized(String collection, String user) throws Exception {
  SolrQueryRequestBase req = new SolrQueryRequestBase(core, new MapSolrParams(new HashMap())) {};
  getProcessor(collection, user).processAdd(new AddUpdateCommand(req));
  getProcessor(collection, user).processDelete(new DeleteUpdateCommand(req));
  DeleteUpdateCommand deleteByQueryCommand = new DeleteUpdateCommand(req);
  deleteByQueryCommand.setQuery("*:*");
  getProcessor(collection, user).processDelete(deleteByQueryCommand);
  getProcessor(collection, user).processMergeIndexes(new MergeIndexesCommand(null, req));
  getProcessor(collection, user).processCommit(new CommitUpdateCommand(req, false));
  getProcessor(collection, user).processRollback(new RollbackUpdateCommand(req));
  getProcessor(collection, user).finish();
}
 

import org.apache.solr.update.DeleteUpdateCommand; //导入方法依赖的package包/类
public void run() {
  // setup the request context early so the logging (including any from 
  // shouldWeDoPeriodicDelete() ) includes the core context info
  final SolrQueryRequest req = new LocalSolrQueryRequest
    (factory.core, Collections.<String,String[]>emptyMap());
  try {
    final SolrQueryResponse rsp = new SolrQueryResponse();
    SolrRequestInfo.setRequestInfo(new SolrRequestInfo(req, rsp));
    try {
      
      if (! factory.iAmInChargeOfPeriodicDeletes() ) {
        // No-Op
        return;
      }
      log.info("Begining periodic deletion of expired docs");

      UpdateRequestProcessorChain chain = core.getUpdateProcessingChain(deleteChainName);
      UpdateRequestProcessor proc = chain.createProcessor(req, rsp);
      if (null == proc) {
        log.warn("No active processors, skipping automatic deletion " + 
                 "of expired docs using chain: {}", deleteChainName);
        return;
      }
      try {
        DeleteUpdateCommand del = new DeleteUpdateCommand(req);
        del.setQuery("{!cache=false}" + expireField + ":[* TO " +
                     DateField.formatExternal(SolrRequestInfo.getRequestInfo().getNOW())
                     + "]");
        proc.processDelete(del);
        
        // TODO: should this be more configurable? 
        // TODO: in particular: should hard commit be optional?
        CommitUpdateCommand commit = new CommitUpdateCommand(req, false);
        commit.softCommit = true;
        commit.openSearcher = true;
        proc.processCommit(commit);
        
      } finally {
        proc.finish();
      }

      log.info("Finished periodic deletion of expired docs");
    } catch (IOException ioe) {
      log.error("IOException in periodic deletion of expired docs: " +
                ioe.getMessage(), ioe);
      // DO NOT RETHROW: ScheduledExecutor will supress subsequent executions
    } catch (RuntimeException re) {
      log.error("Runtime error in periodic deletion of expired docs: " + 
                re.getMessage(), re);
      // DO NOT RETHROW: ScheduledExecutor will supress subsequent executions
    } finally {
      SolrRequestInfo.clearRequestInfo();
    }
  } finally {
    req.close();
  }
}
 

import org.apache.solr.update.DeleteUpdateCommand; //导入方法依赖的package包/类
private void deleteNode(UpdateRequestProcessor processor, SolrQueryRequest request, long dbid) throws IOException
{
    DeleteUpdateCommand delDocCmd = new DeleteUpdateCommand(request);
    delDocCmd.setQuery(FIELD_DBID + ":" + dbid);
    processor.processDelete(delDocCmd);
}
 

import org.apache.solr.update.DeleteUpdateCommand; //导入方法依赖的package包/类
/**
 * Triggers the deletion
 *
 * @param processor the update processor do process deletions
 * @param req       the solr query request information
 * @throws IOException if bad things happen
 */
private void deleteOldDocuments(String deletionQuery, UpdateRequestProcessor processor, SolrQueryRequest req) throws IOException {
    DeleteUpdateCommand delete = new DeleteUpdateCommand(req);
    delete.setQuery(deletionQuery);
    processor.processDelete(delete);
}