} catch (final SQLException ex) {
            throw new SQLRuntimeException(ex);
        }
    }

    /**
     * Returns the update count.
     *
     * @param statement
     *            {@link Statement}. Must not be {@literal null}.
     * @return The update count.
     */
    public static int getUpdateCount(final Statement statement) {
        assertArgumentNotNull("statement", statement);

    private final ByteArrayOutputStream out = new ByteArrayOutputStream();

    @Override
    protected void update(byte b) {
      out.write(b);
    }

    @Override
    protected void update(byte[] b, int off, int len) {
      out.write(b, off, len);
    }

    byte[] bytes() {
      return out.toByteArray();
    }

    public synchronized void insert(final StopwordsItem item) {
        try (StopwordsUpdater updater = new StopwordsUpdater(item)) {
            reload(updater);
        }
    }

    @Override
    public synchronized void update(final StopwordsItem item) {
        try (StopwordsUpdater updater = new StopwordsUpdater(item)) {
            reload(updater);
        }
    }

    @Override

}

func (cs *callbacks) Create() *processor {
	return cs.processors["create"]
}

func (cs *callbacks) Query() *processor {
	return cs.processors["query"]
}

func (cs *callbacks) Update() *processor {
	return cs.processors["update"]
}

func (cs *callbacks) Delete() *processor {
	return cs.processors["delete"]
}

func (cs *callbacks) Row() *processor {
	return cs.processors["row"]
}

        entity.asDocMeta().indexOption(opLambda);
        doInsert(entity, null);
    }

    public void update(SearchLog entity) {
        doUpdate(entity, null);
    }

    public void update(SearchLog entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
        entity.asDocMeta().indexOption(opLambda);
        doUpdate(entity, null);
    }

	return Config{
		ReplicationWorkersWait: opts.ReplicationWorkersWait,
		KeyRotationWorkersWait: opts.KeyRotationWorkersWait,
		ExpirationWorkersWait:  opts.ExpirationWorkersWait,
	}
}

// Update updates opts with nopts
func (opts *Config) Update(nopts Config) {
	configMu.Lock()
	defer configMu.Unlock()

	opts.ReplicationWorkersWait = nopts.ReplicationWorkersWait
	opts.KeyRotationWorkersWait = nopts.KeyRotationWorkersWait

 * views are modifiable.
 *
 * <p>This class is not threadsafe when any concurrent operations update the multimap. Concurrent
 * read operations will work correctly. To allow concurrent update operations, wrap your multimap
 * with a call to {@link Multimaps#synchronizedSetMultimap}.
 *

   * <p>Changes to the returned collection will update the underlying multimap, and vice versa.
   */
  Collection<V> get(@ParametricNullness K key);

  /**
   * Returns a view collection of all <i>distinct</i> keys contained in this multimap. Note that the
   * key set contains a key if and only if this multimap maps that key to at least one value.
   *
   * <p>Changes to the returned set will update the underlying multimap, and vice versa. However,

                () -> new GradleException(
                    "I need to ensure the git tags are up-to-date, but I couldn't find a git remote for [elastic/elasticsearch]"
                )
            );

        LOGGER.info("Updating remote [{}]", upstream);
        // Now update the remote, and make sure we update the tags too
        gitWrapper.updateRemote(upstream);

        LOGGER.info("Updating tags from [{}]", upstream);

errors.storage_tags_update_failure=Failed to update tags of {0}.

success.update_crawler_params = Updated parameters.
success.delete_doc_from_index = Started a process to delete documents from an index.
success.crawling_info_delete_all = Deleted session data.
success.start_crawl_process = Started a crawl process.
success.upload_design_file = Updated {0}.
success.update_design_jsp_file = Updated {0}.