import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
@Override
public List getResultList() {
    try {
        List res = new ArrayList();
        RawRowMapper<T> mapper = dao.getRawRowMapper();
        GenericRawResults<T> r = dao.queryRaw(query, mapper, parameter.values().toArray(new String[parameter.size()]));
        try {
            for (T t : r) {
                res.add(t);
            }
        } finally {
            r.close();
        }
        return res;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
/**
 * Query for all the existing values of a given PoiTag.
 *
 * @param key The key of the PoiTag.
 * @return The list of values.
 */
public List<String> existingValuesForTag(final String key, final Long poiTypeId) {
    return DatabaseHelper.wrapException(new Callable<List<String>>() {
        @Override
        public List<String> call() throws Exception {
            QueryBuilder<Poi, Long> checkPoiTypeQueryBuilder = poiTypeDao.queryBuilder();
            checkPoiTypeQueryBuilder.where().eq(Poi.POI_TYPE_ID, poiTypeId);
            String statement = queryBuilder()
                    .selectColumns(PoiTag.VALUE).distinct()
                    .orderBy(PoiTag.VALUE, true)
                    .join(checkPoiTypeQueryBuilder)
                    .where().eq(PoiTag.KEY, new SelectArg())
                    .prepare().getStatement();
            return queryRaw(statement, new RawRowMapper<String>() {
                @Override
                public String mapRow(String[] columnNames, String[] resultColumns) throws SQLException {
                    return resultColumns[0];
                }
            }, key).getResults();
        }
    });
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
/**
 * Query for the backend id of all PoiNodeRef to update.
 *
 * @return The list of backend ids.
 */
public List<Long> queryAllUpdated() {
    return DatabaseHelper.wrapException(new Callable<List<Long>>() {
        @Override
        public List<Long> call() throws Exception {
            String statement = queryBuilder()
                    .selectColumns(PoiNodeRef.NODE_BACKEND_ID).distinct()
                    .where().eq(PoiNodeRef.UPDATED, true)
                    .prepare().getStatement();
            return queryRaw(statement, new RawRowMapper<Long>() {
                @Override
                public Long mapRow(String[] columnNames, String[] resultColumns) throws SQLException {
                    return Long.parseLong(resultColumns[0]);
                }
            }).getResults();
        }
    });
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
public List<String> queryForTagKeysWithDefaultValues() {
    return DatabaseHelper.wrapException(new Callable<List<String>>() {
        @Override
        public List<String> call() throws Exception {
            String statement = queryBuilder()
                    .selectColumns(PoiTypeTag.KEY).distinct()
                    .where().isNotNull(PoiTypeTag.VALUE)
                    .prepare().getStatement();
            return queryRaw(statement, new RawRowMapper<String>() {
                @Override
                public String mapRow(String[] columnNames, String[] resultColumns) throws SQLException {
                    return resultColumns[0];
                }
            }).getResults();
        }
    });
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
/**
 * Query all POI ids for the given POI type id.
 *
 * @param poiTypeId The id of the POI type
 * @return A list of POI ids
 */
public List<Long> queryAllIdsByPoiTypeId(final Long poiTypeId) {
    return DatabaseHelper.wrapException(new Callable<List<Long>>() {
        @Override
        public List<Long> call() throws Exception {
            String statement = queryBuilder()
                    .selectColumns(Poi.ID).distinct()
                    .where().eq(Poi.POI_TYPE_ID, poiTypeId)
                    .prepare().getStatement();
            return queryRaw(statement, new RawRowMapper<Long>() {
                @Override
                public Long mapRow(String[] columnNames, String[] resultColumns) throws SQLException {
                    return Long.parseLong(resultColumns[0]);
                }
            }).getResults();
        }
    });
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
private void loadSounds() {
    try {
        Dao<Sound, Long> soundDao = getHelper().getSoundDao();
        GenericRawResults<Sound> soundGenericRawResults = soundDao
                .queryRaw(QUERY_SOUNDS, new RawRowMapper<Sound>() {//TODO use DataType?
                    @Override
                    public Sound mapRow(String[] columnNames, String[] resultColumns)
                            throws SQLException {
                        Sound result = new Sound();
                        result.setId(Long.parseLong(resultColumns[0]))
                                .setTitle(resultColumns[1])
                                .setFileName(resultColumns[2]);
                        return result;
                    }
                });
        List<Sound> sounds = soundGenericRawResults.getResults();
        sounds = new ArrayList<>(sounds);
        mSounds = sounds;
        if (mAdapter != null) {
            mAdapter.notifyDataSetChanged();
        }
    } catch (SQLException e) {
        e.printStackTrace();//TODO
    }
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
public <UO> GenericRawResults<UO> queryRaw(ConnectionSource paramConnectionSource, String paramString, RawRowMapper<UO> paramRawRowMapper, String[] paramArrayOfString, ObjectCache paramObjectCache)
{
  logger.debug("executing raw query for: {}", paramString);
  if (paramArrayOfString.length > 0)
    logger.trace("query arguments: {}", paramArrayOfString);
  DatabaseConnection localDatabaseConnection = paramConnectionSource.getReadOnlyConnection();
  CompiledStatement localCompiledStatement = null;
  try
  {
    localCompiledStatement = localDatabaseConnection.compileStatement(paramString, StatementBuilder.StatementType.SELECT, noFieldTypes);
    assignStatementArguments(localCompiledStatement, paramArrayOfString);
    UserObjectRowMapper localUserObjectRowMapper = new UserObjectRowMapper(paramRawRowMapper, this);
    RawResultsImpl localRawResultsImpl = new RawResultsImpl(paramConnectionSource, localDatabaseConnection, paramString, [Ljava.lang.String.class, localCompiledStatement, localUserObjectRowMapper, paramObjectCache);
    return localRawResultsImpl;
  }
  finally
  {
    if (localCompiledStatement != null)
      localCompiledStatement.close();
    if (localDatabaseConnection != null)
      paramConnectionSource.releaseConnection(localDatabaseConnection);
  }
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
@Test
public void testCustomColumnNames() throws Exception {
	Dao<Foo, Integer> dao = createDao(Foo.class, true);
	Foo foo = new Foo();
	foo.val = 1213213;
	assertEquals(1, dao.create(foo));

	final String idName = "SOME_ID";
	final String valName = "SOME_VAL";
	final AtomicBoolean gotResult = new AtomicBoolean(false);
	GenericRawResults<Object> results =
			dao.queryRaw("select id as " + idName + ", val as " + valName + " from foo",
					new RawRowMapper<Object>() {
						@Override
						public Object mapRow(String[] columnNames, String[] resultColumns) {
							assertEquals(idName, columnNames[0]);
							assertEquals(valName, columnNames[1]);
							gotResult.set(true);
							return new Object();
						}
					});
	List<Object> list = results.getResults();
	assertNotNull(list);
	assertEquals(1, list.size());
	assertTrue(gotResult.get());
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
/**
 * Return a results object associated with an internal iterator is mapped by the user's rowMapper.
 */
public <UO> GenericRawResults<UO> queryRaw(ConnectionSource connectionSource, String query,
		RawRowMapper<UO> rowMapper, String[] arguments, ObjectCache objectCache) throws SQLException {
	logger.debug("executing raw query for: {}", query);
	if (arguments.length > 0) {
		// need to do the (Object) cast to force args to be a single object
		logger.trace("query arguments: {}", (Object) arguments);
	}
	DatabaseConnection connection = connectionSource.getReadOnlyConnection(tableInfo.getTableName());
	CompiledStatement compiledStatement = null;
	try {
		compiledStatement = connection.compileStatement(query, StatementType.SELECT, noFieldTypes,
				DatabaseConnection.DEFAULT_RESULT_FLAGS, false);
		assignStatementArguments(compiledStatement, arguments);
		RawResultsImpl<UO> rawResults = new RawResultsImpl<UO>(connectionSource, connection, query, String[].class,
				compiledStatement, new UserRawRowMapper<UO>(rowMapper, this), objectCache);
		compiledStatement = null;
		connection = null;
		return rawResults;
	} finally {
		IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
		if (connection != null) {
			connectionSource.releaseConnection(connection);
		}
	}
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
@Test
public void testCustomColumnNames() throws Exception {
	Dao<Foo, Integer> dao = createDao(Foo.class, true);
	Foo foo = new Foo();
	foo.val = 1213213;
	assertEquals(1, dao.create(foo));
	final String idName = "SOME_ID";
	final String valName = "SOME_VAL";
	final AtomicBoolean gotResult = new AtomicBoolean(false);
	GenericRawResults<Object> results =
			dao.queryRaw("select id as " + idName + ", val as " + valName + " from foo",
					new RawRowMapper<Object>() {
						@Override
						public Object mapRow(String[] columnNames, String[] resultColumns) {
							assertEquals(idName, columnNames[0]);
							assertEquals(valName, columnNames[1]);
							gotResult.set(true);
							return new Object();
						}
					});
	assertEquals(1, results.getResults().size());
	results.close();
	assertTrue(gotResult.get());
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
@Override
public <UO> Observable<GenericRawResults<UO>> rxQueryRaw(final String query, final RawRowMapper<UO> mapper, final String... arguments) {
    final Func0<Observable<GenericRawResults<UO>>> loFunc = () -> {
        try {
            return Observable.just(queryRaw(query, mapper, arguments));
        } catch (SQLException e) {
            return Observable.error(e);
        }
    };
    return Observable.defer(loFunc);
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
/**
 * Return a raw row mapper suitable for use with {@link Dao#queryRaw(String, RawRowMapper, String...)}.
 */
public RawRowMapper<T> getRawRowMapper() {
	if (rawRowMapper == null) {
		rawRowMapper = new RawRowMapperImpl<T, ID>(tableInfo);
	}
	return rawRowMapper;
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
@Override
public Observable<RawRowMapper<DataType>> rxGetRawRowMapper() {
    final Func0<Observable<RawRowMapper<DataType>>> loFunc = () -> Observable.just(getRawRowMapper());
    return Observable.defer(loFunc);
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
public RawRowMapper<T> getRawRowMapper()
{
  if (this.rawRowMapper == null)
    this.rawRowMapper = new RawRowMapperImpl(this.tableInfo);
  return this.rawRowMapper;
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
public UserObjectRowMapper(RawRowMapper<UO> paramRawRowMapper, GenericRowMapper<String[]> paramGenericRowMapper)
{
  this.mapper = paramRawRowMapper;
  this.stringRowMapper = paramGenericRowMapper;
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
@Override
public <UO> GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments) throws SQLException {
    return dao.queryRaw(query, mapper, arguments);
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
@Override
public RawRowMapper<T> getRawRowMapper() {
    return dao.getRawRowMapper();
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
public UserRawRowMapper(RawRowMapper<UO> mapper, GenericRowMapper<String[]> stringMapper) {
	this.mapper = mapper;
	this.stringRowMapper = stringMapper;
}
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
/**
 * Similar to the {@link #queryRaw(String, String...)} but this iterator returns rows that you can map yourself. For
 * every result that is returned by the database, the {@link RawRowMapper#mapRow(String[], String[])} method is
 * called so you can convert the result columns into an object to be returned by the iterator. The arguments are
 * optional but can be set with strings to expand ? type of SQL. For a simple implementation of a raw row mapper,
 * see {@link #getRawRowMapper()}.
 */
<UO> Observable<GenericRawResults<UO>> rxQueryRaw(final String query, final RawRowMapper<UO> mapper, final String... arguments)
;
 

import com.j256.ormlite.dao.RawRowMapper; //导入依赖的package包/类
/**
 * Return a row mapper that is suitable for use with {@link #queryRaw(String, RawRowMapper, String...)}. This is a
 * bit experimental at this time. It most likely will _not_ work with all databases since the string output for each
 * data type is hard to forecast. Please provide feedback.
 */
Observable<RawRowMapper<T>> rxGetRawRowMapper();