@Override public Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos) throws SQLException { return results.getString(columnPos); }
@Override public Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos) throws SQLException { return results.getTimestamp(columnPos); }
@Override public Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos) throws SQLException { return results.getByte(columnPos); }
@Override public String[] mapRow(DatabaseResults results) throws SQLException { int columnN = results.getColumnCount(); String[] result = new String[columnN]; for (int colC = 0; colC < columnN; colC++) { result[colC] = results.getString(colC); } return result; }
@Override public T nextThrow() throws SQLException { if (closed) { return null; } if (!alreadyMoved) { boolean hasResult; if (first) { first = false; hasResult = results.first(); } else { hasResult = results.next(); } // move forward if (!hasResult) { first = false; return null; } } first = false; return getCurrent(); }
@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(); } }
@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(databaseType, 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); } }
/** * 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"); } }
@Override public T first() throws SQLException { if (closed) { return null; } first = false; if (results.first()) { return getCurrent(); } else { return null; } }
@Test public void testMappedQuery() throws Exception { Field field = Foo.class.getDeclaredField(Foo.ID_COLUMN_NAME); String tableName = "basefoo"; Dao<Foo, Integer> dao = createDao(Foo.class, false); FieldType[] resultFieldTypes = new FieldType[] { FieldType.createFieldType(databaseType, tableName, field, Foo.class) }; BaseMappedQuery<Foo, Integer> baseMappedQuery = new BaseMappedQuery<Foo, Integer>(dao, 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); }
@Override public Foo mapRow(DatabaseResults databaseResults) throws SQLException { Foo foo = new Foo(); String[] columnNames = databaseResults.getColumnNames(); for (int i = 0; i < columnNames.length; i++) { if (columnNames[i].equalsIgnoreCase(Foo.ID_COLUMN_NAME)) { foo.id = databaseResults.getInt(i); } else if (columnNames[i].equalsIgnoreCase(Foo.VAL_COLUMN_NAME)) { foo.val = databaseResults.getInt(i); } else if (columnNames[i].equalsIgnoreCase(Foo.STRING_COLUMN_NAME)) { foo.stringField = databaseResults.getString(i); } } return foo; } }
DatabaseConnection.DEFAULT_RESULT_FLAGS, true); DatabaseResults results = stmt.runQuery(null); assertTrue(results.next()); int colNum = results.findColumn(columnName); Field field = clazz.getDeclaredField(columnName); FieldType fieldType = FieldType.createFieldType(databaseType, TABLE_NAME, field, clazz); String stringVal = results.getString(colNum); Object convertedJavaVal = fieldType.convertStringToJavaField(stringVal, 0); assertEquals(javaVal, convertedJavaVal);
@Test public void testSerializableNull() throws Exception { Field[] fields = SerializableField.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field field = fields[0]; FieldType fieldType = FieldType.createFieldType(databaseType, SerializableField.class.getSimpleName(), field, SerializableField.class); DatabaseResults results = createMock(DatabaseResults.class); int fieldNum = 1; expect(results.findColumn(field.getName())).andReturn(fieldNum); expect(results.getTimestamp(fieldNum)).andReturn(null); expect(results.wasNull(fieldNum)).andReturn(true); replay(results); assertNull(fieldType.resultToJava(results, new HashMap<String, Integer>())); verify(results); }
@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; } }
Integer dbColumnPos = columnPositions.get(columnName); if (dbColumnPos == null) { dbColumnPos = results.findColumn(columnName); columnPositions.put(columnName, dbColumnPos); if (results.wasNull(dbColumnPos)) { return null; if (fieldConfig.isThrowIfNull() && results.wasNull(dbColumnPos)) { throw new SQLException( "Results value for primitive field '" + field.getName() + "' was an invalid null value"); } else if (!fieldConverter.isStreamType() && results.wasNull(dbColumnPos)) {
@Test(expected = SQLException.class) public void testNullPrimitiveThrow() throws Exception { Field field = ThrowIfNullNonPrimitive.class.getDeclaredField("primitive"); FieldType fieldType = FieldType.createFieldType(databaseType, ThrowIfNullNonPrimitive.class.getSimpleName(), field, ThrowIfNullNonPrimitive.class); DatabaseResults results = createMock(DatabaseResults.class); int fieldNum = 1; expect(results.findColumn(field.getName())).andReturn(fieldNum); expect(results.getInt(fieldNum)).andReturn(0); expect(results.wasNull(fieldNum)).andReturn(true); replay(results); fieldType.resultToJava(results, new HashMap<String, Integer>()); verify(results); }
@Override public Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos) throws SQLException { return (Long) results.getLong(columnPos); }
@Override public Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos) throws SQLException { return results.getInt(columnPos); }
private String[] getColumnNames(DatabaseResults results) throws SQLException { if (columnNames != null) { return columnNames; } columnNames = results.getColumnNames(); return columnNames; } }
@Override public Object[] mapRow(DatabaseResults results) throws SQLException { int columnN = results.getColumnCount(); Object[] result = new Object[columnN]; for (int colC = 0; colC < columnN; colC++) { DataType dataType; if (colC >= columnTypes.length) { dataType = DataType.STRING; } else { dataType = columnTypes[colC]; } result[colC] = dataType.getDataPersister().resultToJava(null, results, colC); } return result; } }