@Override public SetRowMapper<ResultSet,ResultSet,T,SQLException> newInstance(MapperKey<JdbcColumnKey> jdbcColumnKeyMapperKey) { final JdbcMapperBuilder<T> builder = newBuilder(classMeta); for(JdbcColumnKey key : jdbcColumnKeyMapperKey.getColumns()) { builder.addMapping(key); } return builder.mapper(); } }
private static <T, K> JdbcMapper<T> buildSelectMapper(ClassMeta<T> target, CrudMeta crudMeta, JdbcMapperFactory jdbcMapperFactory) throws SQLException { JdbcMapperBuilder<T> mapperBuilder = jdbcMapperFactory.<T>newBuilder(target); int i = 1; for(ColumnMeta cm : crudMeta.getColumnMetas()) { mapperBuilder.addMapping(cm.toJdbcColumnKey(i)); i++; } return mapperBuilder.mapper(); }
private static <T, K> JdbcMapper<T> buildSelectMapper(ClassMeta<T> target, CrudMeta crudMeta, JdbcMapperFactory jdbcMapperFactory) throws SQLException { JdbcMapperBuilder<T> mapperBuilder = jdbcMapperFactory.<T>newBuilder(target); int i = 1; for(ColumnMeta cm : crudMeta.getColumnMetas()) { mapperBuilder.addMapping(cm.toJdbcColumnKey(i)); i++; } return mapperBuilder.mapper(); }
private void testMatchConstructor(JdbcMapperBuilder<MyObject> builder) throws SQLException { builder.addMapping("prop"); JdbcMapper<MyObject> mapper = builder.mapper(); ResultSet rs = mock(ResultSet.class); when(rs.getString(1)).thenReturn("val"); assertEquals("val", mapper.map(rs).prop.value); } }
private void testMapperBuilderWithIterator(JdbcMapperBuilder<DbObject> builder) throws Exception { addColumn(builder); final JdbcMapper<DbObject> mapper = builder.mapper(); DbHelper.testDbObjectFromDb(new TestRowHandler<PreparedStatement>() { @Override public void handle(PreparedStatement ps) throws Exception { Iterator<DbObject> objects = mapper.iterator(ps.executeQuery()); assertTrue(objects.hasNext()); DbHelper.assertDbObjectMapping(objects.next()); assertFalse(objects.hasNext()); } }); }
private void testIndexedPrimitivesWithNull(JdbcMapperBuilder<DbBoxedPrimitiveObject> builder) throws SQLException, Exception { addIndexedColumn(builder); testPrimitivesWithNullValues(builder.mapper()); } private <T extends PrimitiveObject> void addIndexedColumn(
@Test public void testEnumRoot() throws SQLException { JdbcMapperBuilder<TypeRoot> builder = JdbcMapperFactoryHelper.asm().newBuilder(TypeRoot.class); builder.addMapping("c1"); JdbcMapper<TypeRoot> mapper = builder.mapper(); ResultSet rs = mock(ResultSet.class); when(rs.getObject(1)).thenReturn(0); when(rs.next()).thenReturn(true, false); assertEquals(TypeRoot.type1, mapper.iterator(rs).next()); }
@Test public void testCanCreateTypeFromAmbiguousWithType() throws Exception { JdbcMapperBuilder<MyObjectAmbiguity> builder = JdbcMapperFactoryHelper.asm().newBuilder(MyObjectAmbiguity.class); builder.addMapping("prop", 1, Types.VARCHAR); JdbcMapper<MyObjectAmbiguity> mapper = builder.mapper(); ResultSet rs = mock(ResultSet.class); when(rs.getString(1)).thenReturn("val"); assertEquals("val", mapper.map(rs).prop.value); } private void testMatchConstructor(JdbcMapperBuilder<MyObject> builder)
@Test public void testAsmFailureOnmapper() throws NoSuchFieldException, IllegalAccessException { JdbcMapperBuilder<DbObject> builder = JdbcMapperFactoryHelper.noFailOnAsm().reflectionService(new DefaultReflectionService(newAsmFactoryFailsOnmapper())).newBuilder(DbObject.class); final JdbcMapper<DbObject> mapper = builder.mapper(); Field f = mapper.getClass().getDeclaredField("setRowMapper"); f.setAccessible(true); Object subMapper = f.get(mapper); assertEquals(StaticSetRowMapper.class, subMapper.getClass()); }
@Test public void testIndexedEnumOrdinal() throws Exception { JdbcMapperBuilder<DbEnumObject> builder = JdbcMapperFactoryHelper.asm().newBuilder(DbEnumObject.class); builder.addMapping("val",1, Types.INTEGER); JdbcMapper<DbEnumObject> mapper = builder.mapper(); ResultSet rs = mock(ResultSet.class); when(rs.getInt(1)).thenReturn(2); assertEquals(DbObject.Type.type3, mapper.map(rs).getVal()); }
@Test public void testIndexedEnumString() throws Exception { JdbcMapperBuilder<DbEnumObject> builder = JdbcMapperFactoryHelper.asm().newBuilder(DbEnumObject.class); builder.addMapping("val",1, Types.VARCHAR); JdbcMapper<DbEnumObject> mapper = builder.mapper(); ResultSet rs = mock(ResultSet.class); when(rs.getString(1)).thenReturn("type2"); assertEquals(DbObject.Type.type2, mapper.map(rs).getVal()); }
@Test public void testHandleMapperErrorGetterNotFound() throws NoSuchMethodException, SecurityException, IOException { MapperBuilderErrorHandler errorHandler = mock(MapperBuilderErrorHandler.class); JdbcMapperBuilder<MyClass> builder = JdbcMapperFactoryHelper.asm().mapperBuilderErrorHandler(errorHandler).newBuilder(MyClass.class); builder.addMapping("prop", 1); builder.mapper(); verify(errorHandler).accessorNotFound("Could not find Getter for ColumnKey [columnName=prop, columnIndex=1, sqlType=-99999] returning type class org.simpleflatmapper.test.beans.Foo path prop. See https://github.com/arnaudroger/SimpleFlatMapper/wiki/Errors_CSFM_GETTER_NOT_FOUND"); }
@Override public void handle(PreparedStatement t) throws Exception { ResultSet rs = t.executeQuery(); final JdbcMapper<DbListOfString> mapper = JdbcMapperFactoryHelper.asm().useAsm(asm).newBuilder( DbListOfString.class).addKey("id").addKey("objects_0") .addMapping(rs.getMetaData()).mapper(); List<DbListOfString> strings = mapper.forEach(rs, new ListCollector<DbListOfString>()).getList(); assertEquals(1, strings.size()); assertEquals(12, strings.get(0).getId()); assertEquals(1, strings.get(0).getObjects().size()); } }
@Test public void jdbcMapperGetterNotFound() { try { JdbcMapperFactory.newInstance().newBuilder(Foo2.class).addKey("bar").mapper(); fail(); } catch(MapperBuildingException e) { // assertTrue(e.getMessage().contains("CSFM_GETTER")); // expected } }
@Test public void test544() { final String VALUES_VAL = "values_val"; final String VALUES = "values"; JdbcColumnKey valuesKeys = new JdbcColumnKey(VALUES, 1, Types.VARCHAR); JdbcMapperFactory .newInstance() .addAlias(VALUES, VALUES_VAL) .newBuilder(C544.class) .addMapping(valuesKeys) .mapper(); }
private void validateBuilderInverted(JdbcMapperBuilder<Tuple2<List<Person>, Person>> builder) throws Exception { for(int i = 0; i < columns.length; i++) { builder.addMapping(columns[i]); } final JdbcMapper<Tuple2<List<Person>, Person>> mapper = builder.mapper(); List<Tuple2<List<Person>, Person>> professors = mapper.forEach(setUpResultSetMock(columns, rowsInverted), new ListCollector<Tuple2<List<Person>, Person>>()).getList(); validateProfessorsInverted(professors); }
@Override public void handle(PreparedStatement t) throws Exception { ResultSet rs = t.executeQuery(); JdbcMapper<Db2DeepObject> mapper = builder.addMapping(rs.getMetaData()).mapper(); rs.next(); Db2DeepObject object = mapper.map(rs); assertEquals(33, object.getId()); assertEquals(32, object.getDb1Object().getId()); assertEquals("value12", object.getDb1Object().getValue()); DbHelper.assertDbObjectMapping(object.getDb1Object().getDbObject()); } }, "select 33 as id, "
@Test public void testInstantiateBuilderOnType() throws SQLException { JdbcMapperBuilder<DbObject> builder = new JdbcMapperBuilder<DbObject>(DbObject.class); builder.addMapping("id").addMapping("name"); final JdbcMapper<DbObject> mapper = builder.mapper(); List<DbObject> l = mapper.forEach(new MockDbObjectResultSet(1), new ListCollector<DbObject>()).getList(); assertEquals(1, l.size()); assertEquals(1, l.get(0).getId()); assertEquals("name1", l.get(0).getName()); }
@Test public void testWithWrongColumn() throws MappingException, SQLException { JdbcMapperBuilder<DbObject> builder = JdbcMapperFactoryHelper.asm().mapperBuilderErrorHandler(MapperBuilderErrorHandler.NULL).newBuilder(DbObject.class); builder.addMapping("no_id").addMapping("no_name").addMapping("email"); JdbcMapper<DbObject> mapper = builder.mapper(); List<DbObject> l = mapper.forEach(new MockDbObjectResultSet(1), new ListCollector<DbObject>()).getList(); assertEquals(1, l.size()); assertEquals(0, l.get(0).getId()); assertNull(l.get(0).getName()); assertEquals("email1", l.get(0).getEmail()); }