@Override @SuppressWarnings("deprecation") public void configureForType(ConfigRegistry registry, Annotation annotation, Class<?> sqlObjectType) { RegisterBeanMapper registerBeanMapper = (RegisterBeanMapper) annotation; Class<?> beanClass = registerBeanMapper.value(); String prefix = registerBeanMapper.prefix(); RowMappers mappers = registry.get(RowMappers.class); if (prefix.isEmpty()) { mappers.register(BeanMapper.factory(beanClass)); } else { mappers.register(BeanMapper.factory(beanClass, prefix)); } }
@Before public void setUp() throws Exception { assumeFalse(BindDao.class.getMethod("getByIdImplicitBindPositional", int.class).getParameters()[0].isNamePresent()); h = dbRule.getSharedHandle(); h.registerRowMapper(BeanMapper.factory(Something.class)); h.execute("insert into something (id, name) values (1, 'Elsie Hughes')"); }
@Test public void testColumnNameAnnotation() { Handle handle = dbRule.getSharedHandle(); handle.registerRowMapper(BeanMapper.factory(ColumnNameBean.class)); handle.execute("insert into something (id, name) values (1, 'foo')"); ColumnNameBean bean = handle.createQuery("select * from something") .mapTo(ColumnNameBean.class) .findOnly(); assertThat(bean.getI()).isEqualTo(1); assertThat(bean.getS()).isEqualTo("foo"); }
@Test public void beanMapper() { // tag::beanMapper[] handle.registerRowMapper(BeanMapper.factory(UserBean.class)); List<UserBean> users = handle .createQuery("select id, name from user") .mapTo(UserBean.class) .list(); // end::beanMapper[] assertThat(users).extracting("name").contains("Alice", "Bob", "Charlie", "Data"); }
@Test public void testNestedNotReturned() { Handle handle = dbRule.getSharedHandle(); handle.registerRowMapper(BeanMapper.factory(NestedBean.class)); assertThat(handle .createQuery("select 42 as testValue") .mapTo(NestedBean.class) .findOnly()) .extracting("testValue", "nested") .containsExactly(42, null); }
@Test public void testNestedPrefixNotReturned() { Handle handle = dbRule.getSharedHandle(); handle.registerRowMapper(BeanMapper.factory(NestedPrefixBean.class)); assertThat(handle .createQuery("select 42 as integerValue") .mapTo(NestedPrefixBean.class) .findOnly()) .extracting("integerValue", "nested") .containsExactly(42, null); }
@Test public void testNested() { Handle handle = dbRule.getSharedHandle(); handle.registerRowMapper(BeanMapper.factory(NestedBean.class)); handle.execute("insert into something (id, name) values (1, 'foo')"); assertThat(handle .createQuery("select id, name from something") .mapTo(NestedBean.class) .findOnly()) .extracting("nested.id", "nested.name") .containsExactly(1, "foo"); }
@Test public void mapBeanQualifiedSetter() { dbRule.getJdbi() .registerColumnMapper(new ReversedStringMapper()) .registerRowMapper(BeanMapper.factory(QualifiedSetterThing.class)) .useHandle(handle -> { handle.execute("INSERT INTO something (id, name) VALUES (1, 'abc')"); assertThat(handle.select("SELECT * FROM something") .mapTo(QualifiedSetterThing.class) .findOnly()) .isEqualTo(new QualifiedSetterThing(1, "cba")); }); }
@Test public void testNestedPrefix() { Handle handle = dbRule.getSharedHandle(); handle.registerRowMapper(BeanMapper.factory(NestedPrefixBean.class)); handle.execute("insert into something (id, name) values (1, 'foo')"); assertThat(handle .createQuery("select id nested_id, name nested_name from something") .mapTo(NestedPrefixBean.class) .findOnly()) .extracting("nested.id", "nested.name") .containsExactly(1, "foo"); }
@Test public void mapBeanQualifiedGetter() { dbRule.getJdbi() .registerColumnMapper(new ReversedStringMapper()) .registerRowMapper(BeanMapper.factory(QualifiedGetterThing.class)) .useHandle(handle -> { handle.execute("INSERT INTO something (id, name) VALUES (1, 'abc')"); assertThat(handle.select("SELECT * FROM something") .mapTo(QualifiedGetterThing.class) .findOnly()) .isEqualTo(new QualifiedGetterThing(1, "cba")); }); }
@Test public void mapBeanQualifiedSetterParam() { dbRule.getJdbi() .registerColumnMapper(new ReversedStringMapper()) .registerRowMapper(BeanMapper.factory(QualifiedSetterParamThing.class)) .useHandle(handle -> { handle.execute("INSERT INTO something (id, name) VALUES (1, 'abc')"); assertThat(handle.select("SELECT * FROM something") .mapTo(QualifiedSetterParamThing.class) .findOnly()) .isEqualTo(new QualifiedSetterParamThing(1, "cba")); }); }
@Test public void testNestedStrict() { Handle handle = dbRule.getSharedHandle(); handle.getConfig(ReflectionMappers.class).setStrictMatching(true); handle.registerRowMapper(BeanMapper.factory(NestedBean.class)); handle.execute("insert into something (id, name) values (1, 'foo')"); assertThat(handle .createQuery("select id, name from something") .mapTo(NestedBean.class) .findOnly()) .extracting("nested.id", "nested.name") .containsExactly(1, "foo"); assertThatThrownBy(() -> handle .createQuery("select id, name, 1 as other from something") .mapTo(NestedBean.class) .findOnly()) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("could not match properties for columns: [other]"); }
@Test public void testNestedPrefixStrict() { Handle handle = dbRule.getSharedHandle(); handle.getConfig(ReflectionMappers.class).setStrictMatching(true); handle.registerRowMapper(BeanMapper.factory(NestedPrefixBean.class)); handle.execute("insert into something (id, name, integerValue) values (1, 'foo', 5)"); // three, sir! assertThat(handle .createQuery("select id nested_id, name nested_name, integerValue from something") .mapTo(NestedPrefixBean.class) .findOnly()) .extracting("nested.id", "nested.name", "integerValue") .containsExactly(1, "foo", 5); assertThatThrownBy(() -> handle .createQuery("select id nested_id, name nested_name, 1 as other from something") .mapTo(NestedPrefixBean.class) .findOnly()) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("could not match properties for columns: [other]"); assertThatThrownBy(() -> handle .createQuery("select id nested_id, name nested_name, 1 as nested_other from something") .mapTo(NestedPrefixBean.class) .findOnly()) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("could not match properties for columns: [nested_other]"); }
@Test public void beanMapperPrefix() { handle.execute("create table contacts (id int, name text)"); handle.execute("create table phones (id int, contact_id int, name text, number text)"); handle.execute("insert into contacts (id, name) values (?, ?)", 1, "Alice"); handle.execute("insert into phones (id, contact_id, name, number) values (?, ?, ?, ?)", 100, 1, "Home", "555-1212"); handle.execute("insert into phones (id, contact_id, name, number) values (?, ?, ?, ?)", 101, 1, "Work", "555-9999"); // tag::beanMapperPrefix[] handle.registerRowMapper(BeanMapper.factory(ContactBean.class, "c")); handle.registerRowMapper(BeanMapper.factory(PhoneBean.class, "p")); handle.registerRowMapper(JoinRowMapper.forTypes(ContactBean.class, PhoneBean.class)); List<JoinRow> contactPhones = handle.select("select " + "c.id cid, c.name cname, " + "p.id pid, p.name pname, p.number pnumber " + "from contacts c left join phones p on c.id = p.contact_id") .mapTo(JoinRow.class) .list(); // end::beanMapperPrefix[] assertThat(contactPhones) .extracting(cp -> cp.get(ContactBean.class), cp -> cp.get(PhoneBean.class)) .containsExactly( tuple(new ContactBean(1, "Alice"), new PhoneBean(100, "Home", "555-1212")), tuple(new ContactBean(1, "Alice"), new PhoneBean(101, "Work", "555-9999"))); } }