import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
@Override
public Observable<Integer> rxUpdate(final PreparedUpdate<DataType> preparedUpdate) {
    final Func0<Observable<Integer>> loFunc = () -> {
        try {
            return Observable.just(update(preparedUpdate));
        } catch (SQLException e) {
            return Observable.error(e);
        }
    };
    return Observable.defer(loFunc);
}
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
private static <E extends Entity> long updateAll(final Dao<E, ?> dao, final UpdateBuilder<E, ?> updateBuilder, final Date now) throws SQLException {
	updateBuilder.updateColumnValue(Entity.COLUMN_NAME_UPDATED_AT, now);
	final PreparedUpdate<E> preparedUpdate = updateBuilder.prepare();
	if (LOGGER.isDebugEnabled()) {
		LOGGER.debug("updateAll: " + ReflectionToStringBuilder.toString(dao) + ", " + preparedUpdate);
	}
	final long result = dao.update(preparedUpdate);
	if (LOGGER.isDebugEnabled()) {
		LOGGER.debug("updateAll: " + result);
	}
	return result;
}
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
public int update(PreparedUpdate<T> paramPreparedUpdate)
{
  checkForInitialized();
  DatabaseConnection localDatabaseConnection = this.connectionSource.getReadWriteConnection();
  try
  {
    int i = this.statementExecutor.update(localDatabaseConnection, paramPreparedUpdate);
    return i;
  }
  finally
  {
    this.connectionSource.releaseConnection(localDatabaseConnection);
  }
}
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
public int update(PreparedUpdate<T> paramPreparedUpdate)
{
  try
  {
    int i = this.dao.update(paramPreparedUpdate);
    return i;
  }
  catch (SQLException localSQLException)
  {
    logMessage(localSQLException, "update threw exception on: " + paramPreparedUpdate);
    throw new RuntimeException(localSQLException);
  }
}
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
@Override
public int update(PreparedUpdate<T> preparedUpdate) throws SQLException {
	checkForInitialized();
	DatabaseConnection connection = connectionSource.getReadWriteConnection(tableInfo.getTableName());
	try {
		return statementExecutor.update(connection, preparedUpdate);
	} finally {
		connectionSource.releaseConnection(connection);
	}
}
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
/**
 * @see Dao#update(PreparedUpdate)
 */
@Override
public int update(PreparedUpdate<T> preparedUpdate) {
	try {
		return dao.update(preparedUpdate);
	} catch (SQLException e) {
		logMessage(e, "update threw exception on: " + preparedUpdate);
		throw new RuntimeException(e);
	}
}
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
@Test(expected = RuntimeException.class)
public void testUpdatePreparedThrow() throws Exception {
	@SuppressWarnings("unchecked")
	Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class);
	RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao);
	expect(dao.update((PreparedUpdate<Foo>) null)).andThrow(new SQLException("Testing catch"));
	replay(dao);
	rtDao.update((PreparedUpdate<Foo>) null);
	verify(dao);
}
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
public int update(PreparedUpdate<T> preparedUpdate) throws SQLException {
    return dao.update(preparedUpdate);
}
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
/**
 * Remove metadata references (by updating the field to null) with foreign
 * keys to the metadata parent id
 * 
 * @param parentId
 *            parent id
 * @return updated count
 * @throws SQLException
 */
public int removeMetadataParent(long parentId) throws SQLException {

	UpdateBuilder<MetadataReference, Void> ub = updateBuilder();
	ub.updateColumnValue(MetadataReference.COLUMN_PARENT_ID, null);

	ub.where().eq(MetadataReference.COLUMN_PARENT_ID, parentId);

	PreparedUpdate<MetadataReference> update = ub.prepare();
	int updated = update(update);

	return updated;
}
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
/**
 * Update all rows in the table according to the prepared statement parameter. To use this, the
 * {@link UpdateBuilder} must have set-columns applied to it using the
 * {@link UpdateBuilder#updateColumnValue(String, Object)} or
 * {@link UpdateBuilder#updateColumnExpression(String, String)} methods.
 *
 * @param preparedUpdate A prepared statement to match database rows to be rxDeleted and define the columns to update.
 * @return The number of rows updated in the database.
 * @throws SQLException             on any SQL problems.
 * @throws IllegalArgumentException If there is only an ID field in the object. See the {@link #updateId} method.
 */
Observable<Integer> rxUpdate(final PreparedUpdate<T> preparedUpdate);
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
/**
 * Update all rows in the table according to the prepared statement parameter. To use this, the
 * {@link UpdateBuilder} must have set-columns applied to it using the
 * {@link UpdateBuilder#updateColumnValue(String, Object)} or
 * {@link UpdateBuilder#updateColumnExpression(String, String)} methods.
 * 
 * @param preparedUpdate
 *            A prepared statement to match database rows to be deleted and define the columns to update.
 * @return The number of rows updated in the database.
 * @throws SQLException
 *             on any SQL problems.
 * @throws IllegalArgumentException
 *             If there is only an ID field in the object. See the {@link #updateId} method.
 */
public int update(PreparedUpdate<T> preparedUpdate) throws SQLException;
 

import com.j256.ormlite.stmt.PreparedUpdate; //导入依赖的package包/类
public abstract int update(PreparedUpdate<T> paramPreparedUpdate);