import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
@Test
public void testQueryForOneReleaseConnection() throws Exception {
	Connection connection = createMock(Connection.class);
	PreparedStatement prepStmt = createMock(PreparedStatement.class);
	GeneratedKeyHolder keyHolder = createMock(GeneratedKeyHolder.class);
	ResultSet resultSet = createMock(ResultSet.class);
	@SuppressWarnings("unchecked")
	GenericRowMapper<Foo> rowMapper = createMock(GenericRowMapper.class);

	JdbcDatabaseConnection jdc = new JdbcDatabaseConnection(connection);
	String statement = "statement";
	expect(connection.prepareStatement(statement, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY))
			.andReturn(prepStmt);
	expect(prepStmt.executeQuery()).andReturn(resultSet);
	expect(resultSet.getMetaData()).andReturn(null);
	expect(resultSet.next()).andReturn(false);
	resultSet.close();
	expect(prepStmt.getMoreResults()).andReturn(false);
	// should close the statement
	prepStmt.close();
	connection.close();
	replay(connection, prepStmt, keyHolder, resultSet, rowMapper);
	jdc.queryForOne(statement, new Object[0], new FieldType[0], rowMapper, null);
	jdc.close();
	verify(connection, prepStmt, keyHolder, resultSet, rowMapper);
}
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
@Override
public <T> Object queryForOne(String statement, Object[] args, FieldType[] argFieldTypes,
		GenericRowMapper<T> rowMapper, ObjectCache objectCache) throws SQLException {
	PreparedStatement stmt =
			connection.prepareStatement(statement, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
	if (args != null) {
		statementSetArgs(stmt, args, argFieldTypes);
	}
	DatabaseResults results = new H2DatabaseResults(stmt.executeQuery(), objectCache, true);
	if (!results.next()) {
		// no results at all
		IOUtils.closeThrowSqlException(results, "results");
		return null;
	}
	T first = rowMapper.mapRow(results);
	if (results.next()) {
		return MORE_THAN_ONE;
	} else {
		return first;
	}
}
 

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

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
public GenericRowMapper<T> getSelectStarRowMapper()
{
  try
  {
    GenericRowMapper localGenericRowMapper = this.dao.getSelectStarRowMapper();
    return localGenericRowMapper;
  }
  catch (SQLException localSQLException)
  {
    logMessage(localSQLException, "getSelectStarRowMapper threw exception");
    throw new RuntimeException(localSQLException);
  }
}
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
public <T> Object queryForOne(String paramString, Object[] paramArrayOfObject, FieldType[] paramArrayOfFieldType, GenericRowMapper<T> paramGenericRowMapper, ObjectCache paramObjectCache)
{
  Cursor localCursor = null;
  try
  {
    localCursor = this.db.rawQuery(paramString, toStrings(paramArrayOfObject));
    AndroidDatabaseResults localAndroidDatabaseResults = new AndroidDatabaseResults(localCursor, paramObjectCache);
    logger.trace("{}: queried for one result: {}", this, paramString);
    if (!localAndroidDatabaseResults.first())
      return null;
    Object localObject2 = paramGenericRowMapper.mapRow(localAndroidDatabaseResults);
    if (localAndroidDatabaseResults.next())
    {
      Object localObject3 = MORE_THAN_ONE;
      return localObject3;
    }
    return localObject2;
  }
  catch (android.database.SQLException localSQLException)
  {
    throw SqlExceptionUtil.create("queryForOne from database failed: " + paramString, localSQLException);
  }
  finally
  {
    if (localCursor != null)
      localCursor.close();
  }
}
 

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

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
@Override
public <T> Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
		GenericRowMapper<T> rowMapper, ObjectCache objectCache) throws SQLException {
	if (proxy == null) {
		return null;
	} else {
		return proxy.queryForOne(statement, args, argfieldTypes, rowMapper, objectCache);
	}
}
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void testForeignAutoRefresh() throws Exception {
	Field field = ForeignAutoRefresh.class.getDeclaredField("foreign");
	ConnectionSource connectionSource = createMock(ConnectionSource.class);
	DatabaseConnection connection = createMock(DatabaseConnection.class);
	expect(connectionSource.getDatabaseType()).andReturn(databaseType).anyTimes();
	expect(connectionSource.getReadOnlyConnection("ForeignAutoRefresh")).andReturn(connection);
	ForeignForeign foreignForeign = new ForeignForeign();
	String stuff = "21312j3213";
	int id = 4123123;
	foreignForeign.id = id;
	foreignForeign.stuff = stuff;
	expect(connection.queryForOne(isA(String.class), isA(Object[].class), isA(FieldType[].class),
			isA(GenericRowMapper.class), (ObjectCache) isNull())).andReturn(foreignForeign);
	connectionSource.releaseConnection(connection);
	DatabaseResults results = createMock(DatabaseResults.class);
	ForeignAutoRefresh foreign = new ForeignAutoRefresh();
	replay(results, connectionSource, connection);
	FieldType fieldType = FieldType.createFieldType(connectionSource, ForeignAutoRefresh.class.getSimpleName(),
			field, ForeignAutoRefresh.class);
	fieldType.configDaoInformation(connectionSource, ForeignAutoRefresh.class);
	assertNull(foreign.foreign);
	fieldType.assignField(foreign, id, false, null);
	assertNotNull(foreign.foreign);
	assertEquals(id, foreign.foreign.id);
	assertEquals(stuff, foreign.foreign.stuff);
	verify(results, connectionSource, connection);
}
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
public GenericRowMapper<T> getSelectStarRowMapper()
{
  return this.statementExecutor.getSelectStarRowMapper();
}
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
@Override
public <T> Object queryForOne(String statement, Object[] args, FieldType[] argFieldTypes,
		GenericRowMapper<T> rowMapper, ObjectCache objectCache) throws SQLException {
	return queryForOne(statement, args, argFieldTypes, rowMapper, objectCache, "query for one");
}
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
@Override
public GenericRowMapper<T> getSelectStarRowMapper() throws SQLException {
    return dao.getSelectStarRowMapper();
}
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
@Override
public GenericRowMapper<T> getSelectStarRowMapper() throws SQLException {
	return statementExecutor.getSelectStarRowMapper();
}
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
/**
 * Return a row mapper that is suitable for mapping results from a rxQuery to select * (star).
 */
Observable<GenericRowMapper<T>> rxGetSelectStarRowMapper();
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
/**
 * Return a row mapper that is suitable for mapping results from a query to select * (star).
 */
public GenericRowMapper<T> getSelectStarRowMapper() throws SQLException;
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
/**
 * Perform a SQL query with the associated SQL statement, arguments, and types and returns a single result.
 * 
 * @param statement
 *            SQL statement to use for deleting.
 * @param args
 *            Object arguments for the SQL '?'s.
 * @param argfieldTypes
 *            Field types of the arguments.
 * @param rowMapper
 *            The mapper to use to convert the row into the returned object.
 * @param objectCache
 *            Any object cache associated with the query or null if none.
 * @return The first data item returned by the query which can be cast to T, null if none, the object
 *         {@link #MORE_THAN_ONE} if more than one result was found.
 */
public <T> Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
		GenericRowMapper<T> rowMapper, ObjectCache objectCache) throws SQLException;
 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
public abstract GenericRowMapper<T> getSelectStarRowMapper(); 

import com.j256.ormlite.stmt.GenericRowMapper; //导入依赖的package包/类
public abstract <T> Object queryForOne(String paramString, Object[] paramArrayOfObject, FieldType[] paramArrayOfFieldType, GenericRowMapper<T> paramGenericRowMapper, ObjectCache paramObjectCache);