Java DatabaseResults类代码示例

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
public T queryForFirst(DatabaseConnection paramDatabaseConnection, PreparedStmt<T> paramPreparedStmt, ObjectCache paramObjectCache)
{
  CompiledStatement localCompiledStatement = paramPreparedStmt.compile(paramDatabaseConnection, StatementBuilder.StatementType.SELECT);
  try
  {
    DatabaseResults localDatabaseResults = localCompiledStatement.runQuery(paramObjectCache);
    if (localDatabaseResults.first())
    {
      logger.debug("query-for-first of '{}' returned at least 1 result", paramPreparedStmt.getStatement());
      Object localObject2 = paramPreparedStmt.mapRow(localDatabaseResults);
      return localObject2;
    }
    logger.debug("query-for-first of '{}' returned at 0 results", paramPreparedStmt.getStatement());
    return null;
  }
  finally
  {
    localCompiledStatement.close();
  }
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
public long queryForLong(DatabaseConnection paramDatabaseConnection, PreparedStmt<T> paramPreparedStmt)
{
  CompiledStatement localCompiledStatement = paramPreparedStmt.compile(paramDatabaseConnection, StatementBuilder.StatementType.SELECT_LONG);
  try
  {
    DatabaseResults localDatabaseResults = localCompiledStatement.runQuery(null);
    if (localDatabaseResults.first())
    {
      long l = localDatabaseResults.getLong(0);
      return l;
    }
    throw new SQLException("No result found in queryForLong: " + paramPreparedStmt.getStatement());
  }
  finally
  {
    localCompiledStatement.close();
  }
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
public <T> T resultToJava(DatabaseResults paramDatabaseResults, Map<String, Integer> paramMap)
{
  Integer localInteger1 = (Integer)paramMap.get(this.columnName);
  Integer localInteger2 = localInteger1;
  if (localInteger1 == null)
  {
    localInteger2 = Integer.valueOf(paramDatabaseResults.findColumn(this.columnName));
    paramMap.put(this.columnName, localInteger2);
  }
  Object localObject = this.fieldConverter.resultToJava(this, paramDatabaseResults, localInteger2.intValue());
  if (this.fieldConfig.isForeign())
  {
    if (paramDatabaseResults.wasNull(localInteger2.intValue()))
      return null;
  }
  else if (this.dataPersister.isPrimitive())
  {
    if ((this.fieldConfig.isThrowIfNull()) && (paramDatabaseResults.wasNull(localInteger2.intValue())))
      throw new SQLException("Results value for primitive field '" + this.field.getName() + "' was an invalid null value");
  }
  else if ((!this.fieldConverter.isStreamType()) && (paramDatabaseResults.wasNull(localInteger2.intValue())))
    return null;
  return localObject;
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
@Test(expected = SQLException.class)
public void testDateStringResultInvalid() throws Exception {
	Class<LocalString> clazz = LocalString.class;
	Dao<LocalString, Object> dao = createDao(clazz, true);
	LocalString foo = new LocalString();
	foo.string = "not a date format";
	assertEquals(1, dao.create(foo));
	DatabaseConnection conn = connectionSource.getReadOnlyConnection(TABLE_NAME);
	CompiledStatement stmt = null;
	try {
		stmt =
				conn.compileStatement("select * from " + TABLE_NAME, StatementType.SELECT, noFieldTypes,
						DatabaseConnection.DEFAULT_RESULT_FLAGS, true);
		DatabaseResults results = stmt.runQuery(null);
		assertTrue(results.next());
		int colNum = results.findColumn(STRING_COLUMN);
		DataType.DATE_STRING.getDataPersister().resultToJava(null, results, colNum);
	} finally {
		if (stmt != null) {
			stmt.close();
		}
		connectionSource.releaseConnection(conn);
	}
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
@Test(expected = SQLException.class)
public void testSerializableInvalidResult() throws Exception {
	Class<LocalByteArray> clazz = LocalByteArray.class;
	Dao<LocalByteArray, Object> dao = createDao(clazz, true);
	LocalByteArray foo = new LocalByteArray();
	foo.byteField = new byte[] { 1, 2, 3, 4, 5 };
	assertEquals(1, dao.create(foo));
	DatabaseConnection conn = connectionSource.getReadOnlyConnection(TABLE_NAME);
	CompiledStatement stmt = null;
	try {
		stmt =
				conn.compileStatement("select * from " + TABLE_NAME, StatementType.SELECT, noFieldTypes,
						DatabaseConnection.DEFAULT_RESULT_FLAGS, true);
		DatabaseResults results = stmt.runQuery(null);
		assertTrue(results.next());
		FieldType fieldType =
				FieldType.createFieldType(connectionSource, TABLE_NAME,
						LocalSerializable.class.getDeclaredField(SERIALIZABLE_COLUMN), LocalSerializable.class);
		DataType.SERIALIZABLE.getDataPersister().resultToJava(fieldType, results, results.findColumn(BYTE_COLUMN));
	} finally {
		if (stmt != null) {
			stmt.close();
		}
		connectionSource.releaseConnection(conn);
	}
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
@Test
public void testEnumStringResultsNoFieldType() throws Exception {
	Class<LocalEnumString> clazz = LocalEnumString.class;
	Dao<LocalEnumString, Object> dao = createDao(clazz, true);
	OurEnum val = OurEnum.SECOND;
	LocalEnumString foo = new LocalEnumString();
	foo.ourEnum = val;
	assertEquals(1, dao.create(foo));
	DatabaseConnection conn = connectionSource.getReadOnlyConnection(TABLE_NAME);
	CompiledStatement stmt = null;
	try {
		stmt =
				conn.compileStatement("select * from " + TABLE_NAME, StatementType.SELECT, noFieldTypes,
						DatabaseConnection.DEFAULT_RESULT_FLAGS, true);
		DatabaseResults results = stmt.runQuery(null);
		assertTrue(results.next());
		assertEquals(val.toString(),
				DataType.ENUM_STRING.getDataPersister()
						.resultToJava(null, results, results.findColumn(ENUM_COLUMN)));
	} finally {
		if (stmt != null) {
			stmt.close();
		}
		connectionSource.releaseConnection(conn);
	}
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的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.support.DatabaseResults; //导入依赖的package包/类
/**
 * Return a long value from a prepared query.
 */
public long queryForLong(DatabaseConnection databaseConnection, PreparedStmt<T> preparedStmt) throws SQLException {
	CompiledStatement compiledStatement = preparedStmt.compile(databaseConnection, StatementType.SELECT_LONG);
	DatabaseResults results = null;
	try {
		results = compiledStatement.runQuery(null);
		if (results.first()) {
			return results.getLong(0);
		} else {
			throw new SQLException("No result found in queryForLong: " + preparedStmt.getStatement());
		}
	} finally {
		IOUtils.closeThrowSqlException(results, "results");
		IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
	}
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
@Test
public void testMappedQuery() throws Exception {
	Field field = Foo.class.getDeclaredField(Foo.ID_COLUMN_NAME);
	String tableName = "basefoo";
	FieldType[] resultFieldTypes =
			new FieldType[] { FieldType.createFieldType(connectionSource, tableName, field, Foo.class) };
	BaseMappedQuery<Foo, Integer> baseMappedQuery = new BaseMappedQuery<Foo, Integer>(baseFooTableInfo,
			"select * from " + tableName, new FieldType[0], resultFieldTypes) {
	};
	DatabaseResults results = createMock(DatabaseResults.class);
	int colN = 1;
	expect(results.getObjectCacheForRetrieve()).andReturn(null);
	expect(results.getObjectCacheForStore()).andReturn(null);
	expect(results.findColumn(Foo.ID_COLUMN_NAME)).andReturn(colN);
	int id = 63365;
	expect(results.getInt(colN)).andReturn(id);
	replay(results);
	Foo baseFoo = baseMappedQuery.mapRow(results);
	assertNotNull(baseFoo);
	assertEquals(id, baseFoo.id);
	verify(results);
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
private void checkResults(List<LocalFoo> foos, MappedPreparedStmt<LocalFoo, Integer> preparedQuery, int expectedNum)
		throws SQLException {
	DatabaseConnection conn = connectionSource.getReadOnlyConnection(TABLE_NAME);
	CompiledStatement stmt = null;
	try {
		stmt = preparedQuery.compile(conn, StatementType.SELECT);
		DatabaseResults results = stmt.runQuery(null);
		int fooC = 0;
		while (results.next()) {
			LocalFoo foo2 = preparedQuery.mapRow(results);
			assertEquals(foos.get(fooC).id, foo2.id);
			fooC++;
		}
		assertEquals(expectedNum, fooC);
	} finally {
		IOUtils.closeThrowSqlException(stmt, "compiled statement");
		connectionSource.releaseConnection(conn);
	}
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
@Test(expected = IllegalStateException.class)
public void testHasNextThrow() throws Exception {
	ConnectionSource cs = createMock(ConnectionSource.class);
	cs.releaseConnection(null);
	CompiledStatement stmt = createMock(CompiledStatement.class);
	DatabaseResults results = createMock(DatabaseResults.class);
	expect(stmt.runQuery(null)).andReturn(results);
	expect(results.first()).andThrow(new SQLException("some database problem"));
	stmt.close();
	replay(stmt, results, cs);
	SelectIterator<Foo, Integer> iterator =
			new SelectIterator<Foo, Integer>(Foo.class, null, null, cs, null, stmt, "statement", null);
	try {
		iterator.hasNext();
	} finally {
		iterator.close();
	}
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
@Test(expected = IllegalStateException.class)
public void testNextThrow() throws Exception {
	ConnectionSource cs = createMock(ConnectionSource.class);
	cs.releaseConnection(null);
	CompiledStatement stmt = createMock(CompiledStatement.class);
	DatabaseResults results = createMock(DatabaseResults.class);
	expect(stmt.runQuery(null)).andReturn(results);
	expect(results.first()).andThrow(new SQLException("some result problem"));
	@SuppressWarnings("unchecked")
	GenericRowMapper<Foo> mapper = (GenericRowMapper<Foo>) createMock(GenericRowMapper.class);
	stmt.close();
	replay(stmt, mapper, cs, results);
	SelectIterator<Foo, Integer> iterator =
			new SelectIterator<Foo, Integer>(Foo.class, null, mapper, cs, null, stmt, "statement", null);
	try {
		iterator.hasNext();
	} finally {
		iterator.close();
	}
	verify(stmt, mapper, cs, results);
}
 

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

	CloseableIterator<Foo> iterator =
			dao.iterator(dao.queryBuilder().where().eq(Foo.VAL_COLUMN_NAME, foo.val).prepare());
	try {
		DatabaseResults results = iterator.getRawResults();
		assertTrue(results.first());
		assertTrue(results.getColumnCount() >= 4);
		int valIndex = results.findColumn(Foo.VAL_COLUMN_NAME);
		assertEquals(foo.val, results.getInt(valIndex));
		assertFalse(results.next());
	} finally {
		iterator.closeQuietly();
	}
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
@Test
public void testSerializableNoValue() throws Exception {
	Class<LocalSerializable> clazz = LocalSerializable.class;
	Dao<LocalSerializable, Object> dao = createDao(clazz, true);
	LocalSerializable foo = new LocalSerializable();
	foo.serializable = null;
	assertEquals(1, dao.create(foo));
	DatabaseConnection conn = connectionSource.getReadOnlyConnection(TABLE_NAME);
	CompiledStatement stmt = null;
	try {
		stmt = conn.compileStatement("select * from " + TABLE_NAME, StatementType.SELECT, noFieldTypes,
				DatabaseConnection.DEFAULT_RESULT_FLAGS, true);
		DatabaseResults results = stmt.runQuery(null);
		assertTrue(results.next());
		FieldType fieldType = FieldType.createFieldType(connectionSource, TABLE_NAME,
				clazz.getDeclaredField(SERIALIZABLE_COLUMN), clazz);
		assertNull(DataType.SERIALIZABLE.getDataPersister().resultToJava(fieldType, results,
				results.findColumn(SERIALIZABLE_COLUMN)));
	} finally {
		if (stmt != null) {
			stmt.close();
		}
		connectionSource.releaseConnection(conn);
	}
}
 

import com.j256.ormlite.support.DatabaseResults; //导入依赖的package包/类
@Test(expected = SQLException.class)
public void testSerializableInvalidResult() throws Exception {
	Class<LocalByteArray> clazz = LocalByteArray.class;
	Dao<LocalByteArray, Object> dao = createDao(clazz, true);
	LocalByteArray foo = new LocalByteArray();
	foo.byteField = new byte[] { 1, 2, 3, 4, 5 };
	assertEquals(1, dao.create(foo));
	DatabaseConnection conn = connectionSource.getReadOnlyConnection(TABLE_NAME);
	CompiledStatement stmt = null;
	try {
		stmt = conn.compileStatement("select * from " + TABLE_NAME, StatementType.SELECT, noFieldTypes,
				DatabaseConnection.DEFAULT_RESULT_FLAGS, true);
		DatabaseResults results = stmt.runQuery(null);
		assertTrue(results.next());
		FieldType fieldType = FieldType.createFieldType(connectionSource, TABLE_NAME,
				LocalSerializable.class.getDeclaredField(SERIALIZABLE_COLUMN), LocalSerializable.class);
		DataType.SERIALIZABLE.getDataPersister().resultToJava(fieldType, results, results.findColumn(BYTE_COLUMN));
	} finally {
		if (stmt != null) {
			stmt.close();
		}
		connectionSource.releaseConnection(conn);
	}
}