Jdbi 3 Developer Guide

<dependencies>
    <dependency>
        <groupId>org.jdbi</groupId>
        <artifactId>jdbi3-core</artifactId>
        <version>3.47.1-SNAPSHOT</version>
    </dependency>
</dependencies>

dependencies {
    implementation("org.jdbi:jdbi3-core:3.47.1-SNAPSHOT")
}

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-bom</artifactId>
            <type>pom</type>
            <version>3.47.1-SNAPSHOT</version>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.jdbi</groupId>
        <artifactId>jdbi3-core</artifactId>
    </dependency>
</dependencies>

dependencies {
    // Load bill of materials (BOM) for Jdbi.
    implementation(platform("org.jdbi:jdbi3-bom:3.47.1-SNAPSHOT"))
}

dependencies {
    implementation("org.jdbi:jdbi3-core")
}

List<String> names = jdbi.withHandle(handle ->
    handle.createQuery("select name from contacts")
          .mapTo(String.class)
          .list());
assertThat(names).contains("Alice", "Bob");

jdbi.useHandle(handle -> {
    handle.execute("create table contacts (id int primary key, name varchar(100))");
    handle.execute("insert into contacts (id, name) values (?, ?)", 1, "Alice");
    handle.execute("insert into contacts (id, name) values (?, ?)", 2, "Bob");
});

try (Handle handle = jdbi.open()) {
    result = handle.execute("insert into contacts (id, name) values (?, ?)", 3, "Chuck");
}

try (Handle handle = jdbi.open()) {
    Iterator<String> names = handle.createQuery("select name from contacts where id = 1")
            .mapTo(String.class)
            .iterator();
    assertThat(names).hasNext();
    String name = names.next();
    assertThat(name).isEqualTo("Alice");
    assertThat(names).isExhausted();
}

List<Map<String, Object>> users =
    handle.createQuery("SELECT id, \"name\" FROM \"user\" ORDER BY id ASC")
        .mapToMap()
        .list();

assertThat(users).containsExactly(
        map("id", 1, "name", "Alice"),
        map("id", 2, "name", "Bob"));

String name = handle.select("SELECT name FROM users WHERE id = ?", 3)
    .mapTo(String.class)
    .one();

Optional<String> name = handle.select(...)
    .mapTo(String.class)
    .findOne();

String name = handle.select("SELECT name FROM users WHERE id = ?", 3)
    .mapTo(String.class)
    .first();

Optional<String> name = handle.select(...)
    .mapTo(String.class)
    .findFirst();

List<String> names = this.handle
        .createQuery("SELECT title FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(String.class)
        .list();

Set<String> names = handle
        .createQuery("SELECT title FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(String.class)
        .set();

List<String> names = handle
        .registerCollector(List.class, Collectors.toCollection(LinkedList::new))
        .createQuery("SELECT title FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(String.class)
        .collectIntoList();

Set<String> names = handle
        .registerCollector(Set.class, Collectors.toCollection(LinkedHashSet::new))
        .createQuery("SELECT title FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(String.class)
        .collectIntoSet();

List<String> names = handle
        .createQuery("SELECT title FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(String.class)
        .collectInto(List.class); (1)

List<String> names = handle
        .createQuery("SELECT title FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(String.class)
        .collectInto(GenericTypes.parameterizeClass(List.class, String.class)); (2)

Set<String> names = handle
        .createQuery("SELECT title FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(String.class)
        .collect(Collectors.toSet());

Set<String> names = handle
        .createQuery("SELECT title FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(String.class)
        .toCollection(() -> new LinkedHashSet<>());

Map<Integer, String> names = handle
        .registerRowMapper(Movie.class, ConstructorMapper.of(Movie.class))
        .createQuery("SELECT * FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(Movie.class)
        .collectToMap(Movie::id, Movie::title);

List<String> names = new ArrayList<>();
handle.createQuery(
                "SELECT title FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(String.class)
        .useStream(stream -> stream.forEach(names::add)); (1)

List<String> names = new ArrayList<>();
try (Stream<String> stream = handle.createQuery(
                "SELECT title FROM films WHERE genre = :genre ORDER BY title")
        .bind("genre", "Action")
        .mapTo(String.class)
        .stream()) { (2)

    stream.forEach(names::add);
}

int releaseDate = handle
        .createQuery("SELECT release_year FROM films WHERE title = :title")
        .bind("title", "The Dark Knight")
        .mapTo(Integer.class)
        .one();

Movie movie = handle
        .registerRowMapper(Movie.class, ConstructorMapper.of(Movie.class))
        .createQuery("SELECT * FROM films WHERE id = :id")
        .bind("id", 1)
        .mapTo(Movie.class)
        .one();

count = handle.execute("INSERT INTO \"user\" (id, \"name\") VALUES(?, ?)", 4, "Alice");
assertThat(count).isOne();

int count = handle.createUpdate("INSERT INTO \"user\" (id, \"name\") VALUES(:id, :name)")
    .bind("id", 3)
    .bind("name", "Charlie")
    .execute();
assertThat(count).isOne();

Batch batch = handle.createBatch();

batch.add("INSERT INTO fruit VALUES(0, 'apple')");
batch.add("INSERT INTO fruit VALUES(1, 'banana')");

int[] rowsModified = batch.execute();

PreparedBatch batch = handle.prepareBatch("INSERT INTO \"user\" (id, \"name\") VALUES(:id, :name)");
for (int i = 100; i < 5000; i++) {
    batch.bind("id", i).bind("name", "User:" + i).add();
}
int[] counts = batch.execute();

public void testSqlObjectBatch() {
    BasketOfFruit basket = handle.attach(BasketOfFruit.class);

    int[] rowsModified = basket.fillBasket(Arrays.asList(
            new Fruit(0, "apple"),
            new Fruit(1, "banana")));

    assertThat(rowsModified).containsExactly(1, 1);
    assertThat(basket.countFruit()).isEqualTo(2);
}

public interface BasketOfFruit {
    @SqlBatch("INSERT INTO fruit VALUES(:id, :name)")
    int[] fillBasket(@BindBean Collection<Fruit> fruits);

    @SqlQuery("SELECT count(1) FROM fruit")
    int countFruit();
}

try (Script script = handle.createScript("INSERT INTO \"user\" VALUES(3, 'Charlie');"
        + "UPDATE \"user\" SET \"name\"='Bobby Tables' WHERE id=2;")) {
    int[] results = script.execute();

    assertThat(results).containsExactly(1, 1);
}

jdbi.withHandle(h -> {
    // turn off trailing semicolons for script statements
    h.getConfig(SqlStatements.class).setScriptStatementsNeedSemicolon(false);
    return h.createScript(ClasspathSqlLocator.removingComments()
            .getResource("scripts/mysql-script.sql"))
        .execute();
    });

String url = h.queryMetadata(DatabaseMetaData::getURL);
boolean supportsTransactions = h.queryMetadata(DatabaseMetaData::supportsTransactions);

List<String> catalogNames = h.queryMetadata(DatabaseMetaData::getCatalogs)
            .mapTo(String.class)
            .list();

try (Handle handle = jdbi.open()) {
    for (int i = 0; i < 100_000; i++) {
        try (Update update = handle.createUpdate("INSERT INTO users (id, name) VALUES (:id, :name)")) {
            update.bind("id", i)
                  .bind("name", "user_" + i)
                  .execute();
        }
    }
}

try (Handle handle = jdbi.open()) {
    for (int i = 0; i < 100_000; i++) {
        Update update = handle.createUpdate("INSERT INTO users (id, name) VALUES (:id, :name)");
        try {
            update.bind("id", i)
                  .bind("name", "user_" + i)
                  .execute();
        } finally {
            update.close();
        }
    }
}

try (Handle handle = jdbi.open()) {
    List<User> users = handle
        .createQuery("SELECT * from users") (1)
        .mapTo(User.class) (2)
        .list(); (3)
}

// managing resources through the query SQL statement
try (Handle handle = jdbi.open()) {
    try (Query query = handle.createQuery("SELECT * from users")) { (1)
        Stream<User> users = query.mapTo(User.class).stream();
        // consume the stream
    }
}

// managing resources through the stream
try (Handle handle = jdbi.open()) {
    try (Stream<User> users = handle.createQuery("SELECT * from users")
        .mapTo(User.class)
        .stream()) { (2)
            // consume the stream
        }
}

Stream<User> userStream = jdbi.withHandle(handle ->
    handle.createQuery("SELECT * from users")
        .mapTo(User.class)
        .stream();  (1)
    });  (2)

Optional<User> user = stream.findFirst(); (3)

try (Handle handle = jdbi.open()) {
    try (Query query = handle.createQuery("SELECT * from users")) {
        query.mapTo(User.class).useIterator(it -> {
            // consume the iterator contents
        });
    }
}

jdbi.useHandle(handle -> {
    handle.createQuery("SELECT * from users")
        .mapTo(User.class)
        .useIterator(it -> {
            // consume the iterator contents
        });
    });

try (Call call = h.createCall("{call some_procedure()}")) {
    OutParameters output = call.invoke();

    output.getRowSet("result") (1)
        .mapTo(SomeType.class) (2)
        .useStream(stream -> { ... consume stream ... }); (3)
}

// DOES NOT WORK!
OutParameters out  = jdbi.withHandle(handle -> {
    Call call = handle.createCall("{call some_procedure()}");
    return call.invoke(); (1)
}); (2)
String result = out.getString("result"); (3)

// process the OutParameters within the handle callback
String result  = jdbi.withHandle(handle -> {
    Call call = handle.createCall("{call some_procedure()}");
    OutParameters out = call.invoke();
    return out.getString("result");
});

// use a callback method from the Call statement
String result  = jdbi.withHandle(handle -> {
    Call call = handle.createCall("{call some_procedure()}");
    return call.invoke(out -> out.getString("result"));
});

Optional<User> user = handle.createQuery("SELECT * FROM users WHERE id = :id")
        .attachToHandleForCleanup() (1)
        .bind("id", id)
        .mapTo(User.class)
        .stream()
        .findAny();

jdbi.getConfig(SqlStatements.class)
    .setAttachAllStatementsForCleanup(true);

try (Handle handle = jdbi.open()) {
    Optional<User> user = handle.createQuery("SELECT * FROM users WHERE id = :id")
        .bind("id", id)
        .mapTo(User.class)
        .stream()
        .findAny();
}

try (Handle handle = jdbi.open()) {
    handle.getConfig(SqlStatements.class)
        .setAttachAllStatementsForCleanup(true);

    Optional<User> user = handle.createQuery("SELECT * FROM users WHERE id = :id")
        .bind("id", id)
        .mapTo(User.class)
        .stream()
        .findAny();
}

User user = jdbi.withHandle(handle ->
    handle.createQuery("SELECT * FROM users WHERE id = :id")
        .bind("id", id)
        .mapTo(User.class)
        .one());

jdbi.useHandle(handle -> {
    handle.getConfig(SqlStatements.class).setAttachCallbackStatementsForCleanup(false); (1)

    for (int i = 0; i < 100_000; i++) {
        try (Update update = handle.createUpdate("INSERT INTO users (id, name) VALUES (:id, :name)")) {
            update.bind("id", i)
                  .bind("name", "user_" + i)
                  .execute();
        }
    }
});

static class UUIDArgument implements Argument {
    private UUID uuid;

    UUIDArgument(UUID uuid) {
        this.uuid = uuid;
    }

    @Override
    public void apply(int position, PreparedStatement statement, StatementContext ctx) throws SQLException {
        statement.setString(position, uuid.toString()); (1)
    }
}

@Test
public void uuidArgument() {
    UUID u = UUID.randomUUID();
    assertThat(handle.createQuery("SELECT CAST(:uuid AS VARCHAR)")
        .bind("uuid", new UUIDArgument(u))
        .mapTo(String.class)
        .one()).isEqualTo(u.toString());
}

static class UUIDArgumentFactory extends AbstractArgumentFactory<UUID> {
    UUIDArgumentFactory() {
        super(Types.VARCHAR); (1)
    }

    @Override
    protected Argument build(UUID value, ConfigRegistry config) {
        return (position, statement, ctx) -> statement.setString(position, value.toString()); (2)
    }
}

@Test
public void uuidArgumentFactory() {
    UUID u = UUID.randomUUID();
    handle.registerArgument(new UUIDArgumentFactory());
    assertThat(handle.createQuery("SELECT CAST(:uuid AS VARCHAR)")
        .bind("uuid", u)
        .mapTo(String.class)
        .one()).isEqualTo(u.toString());
}

jdbi.registerRowMapper(User.class,
    (rs, ctx) -> new User(rs.getInt("id"), rs.getString("name"));

try (Handle handle = jdbi.open()) {
    List<User> users = handle
        .createQuery("SELECT id, name FROM user ORDER BY id ASC")
        .mapTo(User.class)
        .list();
}

handle.registerRowMapper(new UserMapper());

public final class Pair<L, R> {
    public final L left;
    public final R right;

    public Pair(L left, R right) {
        this.left = left;
        this.right = right;
    }
}

public class PairMapperFactory implements RowMapperFactory {
    public Optional<RowMapper<?>> build(Type type, ConfigRegistry config) {
        // ...
    }
}

if (!Pair.class.equals(GenericTypes.getErasedType(type))) {
    return Optional.empty();
}

Type leftType = GenericTypes.resolveType(Pair.class.getTypeParameters()[0], type);
Type rightType = GenericTypes.resolveType(Pair.class.getTypeParameters()[1], type);

ColumnMappers columnMappers = config.get(ColumnMappers.class);

ColumnMapper<?> leftMapper = columnMappers.findFor(leftType)
    .orElseThrow(() -> new NoSuchMapperException(
        "No column mapper registered for Pair left parameter " + leftType));
ColumnMapper<?> rightMapper = columnMappers.findFor(rightType)
    .orElseThrow(() -> new NoSuchMapperException(
        "No column mapper registered for Pair right parameter " + rightType));

RowMapper<?> pairMapper = (rs, ctx) ->
    new Pair(leftMapper.map(rs, 1, ctx), // In JDBC, column numbers start at 1
             rightMapper.map(rs, 2, ctx));

return Optional.of(pairMapper);

public class PairMapperFactory implements RowMapperFactory {
    public Optional<RowMapper<?>> build(Type type, ConfigRegistry config) {
        if (!Pair.class.equals(GenericTypes.getErasedType(type))) {
            return Optional.empty();
        }

        Type leftType = GenericTypes.resolveType(Pair.class.getTypeParameters()[0], type);
        Type rightType = GenericTypes.resolveType(Pair.class.getTypeParameters()[1], type);

        ColumnMappers columnMappers = config.get(ColumnMappers.class);

        ColumnMapper<?> leftMapper = columnMappers.findFor(leftType)
            .orElseThrow(() -> new NoSuchMapperException(
                "No column mapper registered for Pair left parameter " + leftType));
        ColumnMapper<?> rightMapper = columnMappers.findFor(rightType)
            .orElseThrow(() -> new NoSuchMapperException(
                "No column mapper registered for Pair right parameter " + rightType));

        RowMapper<?> pairMapper = (rs, ctx) -> new Pair(leftMapper.map(rs, 1, ctx),
            rightMapper.map(rs, 2, ctx));

        return Optional.of(pairMapper);
    }
}

jdbi.registerRowMapper(new PairMapperFactory());

try (Handle handle = jdbi.open()) {
    List<Pair<String, String>> configPairs = handle
        .createQuery("SELECT key, value FROM config")
        .mapTo(new GenericType<Pair<String, String>>() {})
        .list();
}

jdbi.registerColumnMapper(Money.class,
    (rs, col, ctx) -> Money.parse(rs.getString(col)));

List<Money> amounts = jdbi.withHandle(handle ->
    handle.select("SELECT amount FROM transactions WHERE account_id = ?", accountId)
        .mapTo(Money.class)
        .list());

handle.registerColumnMapper(new MoneyMapper());

public class OptionalColumnMapperFactory implements ColumnMapperFactory {
    public Optional<ColumnMapper<?>> build(Type type, ConfigRegistry config) {
        // ...
    }
}

if (!Optional.class.equals(GenericTypes.getErasedType(type))) {
    return Optional.empty();
}

Type t = GenericTypes.resolveType(Optional.class.getTypeParameters()[0], type);

ColumnMapper<?> tMapper = config.get(ColumnMappers.class)
    .findFor(embeddedType)
    .orElseThrow(() -> new NoSuchMapperException(
        "No column mapper registered for parameter " + embeddedType + " of type " + type));

ColumnMapper<?> optionalMapper = (rs, col, ctx) ->
    Optional.ofNullable(tMapper.map(rs, col, ctx));

return Optional.of(optionalMapper);

public class OptionalColumnMapperFactory implements ColumnMapperFactory {
    public Optional<ColumnMapper<?>> build(Type type, ConfigRegistry config) {
        if (!Optional.class.equals(GenericTypes.getErasedType(type))) {
            return Optional.empty();
        }

        Type t = GenericTypes.resolveType(Optional.class.getTypeParameters()[0], type);

        ColumnMapper<?> tMapper = config.get(ColumnMappers.class)
            .findFor(t)
            .orElseThrow(() -> new NoSuchMapperException(
                "No column mapper registered for parameter " + t + " of type " + type));

        ColumnMapper<?> optionalMapper = (rs, col, ctx) -> Optional.ofNullable(tMapper.map(rs, col, ctx));

        return Optional.of(optionalMapper);
    }
}

jdbi.registerColumnMapper(new OptionalColumnMapperFactory());

try (Handle handle = jdbi.open()) {
    List<Optional<String>> middleNames = handle
        .createQuery("SELECT middle_name FROM contacts")
        .mapTo(new GenericType<Optional<String>>() {})
        .list();
}

public User(int id, String name) {
    this.id = id;
    this.name = name;
}

public User(@ColumnName("id") int id, @ColumnName("name") String name) {
    this.id = id;
    this.name = name;
}

@ConstructorProperties({"id", "name"})
public User(int id, String name) {
    this.id = id;
    this.name = name;
}

handle.registerRowMapper(ConstructorMapper.factory(User.class));
Set<User> userSet = handle.createQuery("SELECT * FROM \"user\" ORDER BY id ASC")
    .mapTo(User.class)
    .collect(Collectors.toSet());

assertThat(userSet).hasSize(4);

handle.registerRowMapper(ConstructorMapper.factory(Contact.class, "c"));
handle.registerRowMapper(ConstructorMapper.factory(Phone.class, "p"));
handle.registerRowMapper(JoinRowMapper.forTypes(Contact.class, Phone.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();

public User(@ColumnName("user_id") int id, String name) {
    this.id = id;
    this.name = name;
}

public class User {
    public User(int id,
                String name,
                @Nested Address address) {
        // ...
    }
}

public class Address {
    public Address(String street,
                   String city,
                   String state,
                   String zip) {
        // ...
    }
}

handle.registerRowMapper(ConstructorMapper.factory(User.class));

List<User> users = handle
    .select("SELECT id, name, street, city, state, zip FROM users")
    .mapTo(User.class)
    .list();

public User(int id,
            String name,
            @Nested("addr") Address address) {
    // ...
}

handle.registerRowMapper(ConstructorMapper.factory(User.class));

List<User> users = handle
    .select("SELECT id, name, addr_street, addr_city, addr_state, addr_zip FROM users")
    .mapTo(User.class)
    .list();

public class User {
    public User(int id,
                String name,
                @Nullable String passwordHash,
                @Nullable @Nested Address address) {
        // ...
    }
}

public class UserBean {
    private int id;
    private String name;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

handle.registerRowMapper(BeanMapper.factory(UserBean.class));

List<UserBean> users = handle
        .createQuery("select id, \"name\" from \"user\"")
        .mapTo(UserBean.class)
        .list();

List<UserBean> users = handle
        .createQuery("select id, \"name\" from \"user\"")
        .mapToBean(UserBean.class)
        .list();

List<UserBean> users = handle
    .createQuery("select id, \"name\" from \"user\"")
    .map(BeanMapper.of(UserBean.class))
    .list();

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();

public class User {
    private int id;

    @ColumnName("user_id")
    public int getId() { return id; }

    public void setId(int id) { this.id = id; }
}

public class User {
    private int id;
    private String name;
    private Address address;

    // ... (getters and setters)

    @Nested (1)
    public Address getAddress() { ... }

    public void setAddress(Address address) { ... }
}

public class Address {
    private String street;
    private String city;
    private String state;
    private String zip;

    // ... (getters and setters)
}

handle.registerRowMapper(BeanMapper.factory(User.class));

List<User> users = handle
    .select("SELECT id, name, street, city, state, zip FROM users")
    .mapTo(User.class)
    .list();

@Nested("addr")
public Address getAddress() { ... }

handle.registerRowMapper(BeanMapper.factory(User.class));

List<User> users = handle
    .select("SELECT id, name, addr_street, addr_city, addr_state, addr_zip FROM users")
    .mapTo(User.class)
    .list();

public class User {
    public int id;

    public String name;
}

handle.registerRowMapper(FieldMapper.factory(User.class));

List<UserBean> users = handle
    .createQuery("SELECT id, name FROM user")
    .mapTo(User.class)
    .list();

handle.registerRowMapper(FieldMapper.factory(Contact.class, "c"));
handle.registerRowMapper(FieldMapper.factory(Phone.class, "p"));
handle.registerRowMapper(JoinRowMapper.forTypes(Contact.class, Phone.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();

public class User {
    @ColumnName("user_id")
    public int id;

    public String name;
}

public class User {
    public int id;
    public String name;

    @Nested
    public Address address;
}

public class Address {
    public String street;
    public String city;
    public String state;
    public String zip;
}

handle.registerRowMapper(FieldMapper.factory(User.class));

List<User> users = handle
    .select("SELECT id, name, street, city, state, zip FROM users")
    .mapTo(User.class)
    .list();

public class User {
    public int id;
    public String name;

    @Nested("addr")
    public Address address;
}

handle.registerRowMapper(FieldMapper.factory(User.class));

List<User> users = handle
    .select("SELECT id, name, addr_street, addr_city, addr_state, addr_zip FROM users")
    .mapTo(User.class)
    .list();

ResultIterable<User> resultIterable = handle
    .createQuery("SELECT * from users")
    .mapTo(User.class);

List<User> users = resultIterable.list();

handle.createQuery("SELECT id, name FROM user ORDER BY id ASC")
    .map(new UserMapper())
    .useStream(stream -> {
        Optional<String> first = stream
            .filter(u -> u.id > 2)
            .map(u -> u.name)
            .findFirst();
        assertThat(first).contains("Charlie");
    });

List<User> users =
    handle.createQuery("SELECT id, name FROM user")
        .map(new UserMapper())
        .list();

h.execute("INSERT INTO something (id, name) VALUES (1, 'Alice'), (2, 'Bob'), (3, 'Chuckles')");
Map<Integer, Something> users = h.createQuery("SELECT id, name FROM something")
    .mapTo(Something.class)
    .collect(Collector.of(HashMap::new, (accum, item) -> {
        accum.put(item.getId(), item);   // Each entry is added into an accumulator map
    }, (l, r) -> {
        l.putAll(r);                     // While jdbi does not process rows in parallel,
        return l;                        // the Collector contract encourages writing combiners
    }, Characteristics.IDENTITY_FINISH));

List<Contact> contacts = handle.createQuery(SELECT_ALL)
    .registerRowMapper(BeanMapper.factory(Contact.class, "c"))
    .registerRowMapper(BeanMapper.factory(Phone.class, "p")) (1)
    .reduceRows(new LinkedHashMap<Long, Contact>(), (2)
        (map, rowView) -> {
            Contact contact = map.computeIfAbsent( (3)
                rowView.getColumn("c_id", Long.class),
                id -> rowView.getRow(Contact.class));

            if (rowView.getColumn("p_id", Long.class) != null) { (4)
                contact.addPhone(rowView.getRow(Phone.class));
            }

            return map; (5)
        })
    .values() (6)
    .stream()
    .collect(toList()); (7)

List<Contact> contacts = handle.createQuery(SELECT_ALL)
    .registerRowMapper(BeanMapper.factory(Contact.class, "c"))
    .registerRowMapper(BeanMapper.factory(Phone.class, "p"))
    .reduceRows((Map<Long, Contact> map, RowView rowView) -> { (1)
        Contact contact = map.computeIfAbsent(
            rowView.getColumn("c_id", Long.class),
            id -> rowView.getRow(Contact.class));

        if (rowView.getColumn("p_id", Long.class) != null) {
            contact.addPhone(rowView.getRow(Phone.class));
        }
        (2)
    })
    .collect(toList()); (3)

Optional<Contact> contact = handle.createQuery(SELECT_ONE)
    .bind("id", contactId)
    .registerRowMapper(BeanMapper.factory(Contact.class, "c"))
    .registerRowMapper(BeanMapper.factory(Phone.class, "p"))
    .reduceRows(LinkedHashMapRowReducer.<Long, Contact> of((map, rowView) -> {
      Contact contact = map.orElseGet(() -> rowView.getRow(Contact.class));

      if (rowView.getColumn("p_id", Long.class) != null) {
        contact.addPhone(rowView.getRow(Phone.class));
      }
    })
    .findFirst();

List<Contact> contacts = handle.createQuery(SELECT_ALL)
    .reduceResultSet(new LinkedHashMap<Long, Contact>(),
        (acc, resultSet, ctx) -> {
            long contactId = resultSet.getLong("c_id");
            Contact contact;
            if (acc.containsKey(contactId)) {
                contact = acc.get(contactId);
            } else {
                contact = new Contact();
                acc.put(contactId, contact);
                contact.setId(contactId);
                contact.setName(resultSet.getString("c_name"));
            }

            long phoneId = resultSet.getLong("p_id");
            if (!resultSet.wasNull()) {
                Phone phone = new Phone();
                phone.setId(phoneId);
                phone.setType(resultSet.getString("p_type"));
                phone.setPhone(resultSet.getString("p_phone"));
                contact.addPhone(phone);
            }

            return acc;
        })
    .values()
    .stream()
    .collect(toList());

h.registerRowMapper(ConstructorMapper.factory(User.class));
h.registerRowMapper(ConstructorMapper.factory(Article.class));

Multimap<User, Article> joined = HashMultimap.create();
h.createQuery("SELECT * FROM \"user\" NATURAL JOIN author NATURAL JOIN article")
    .map(JoinRowMapper.forTypes(User.class, Article.class))
    .forEach(jr -> joined.put(jr.get(User.class), jr.get(Article.class)));

public interface UserArticleDao {

    @RegisterJoinRowMapper({User.class, Article.class})
    @SqlQuery("SELECT * FROM \"user\" NATURAL JOIN author NATURAL JOIN article")
    Stream<JoinRow> getAuthorship();
}

Multimap<User, Article> joined = HashMultimap.create();

handle.attach(UserArticleDao.class)
    .getAuthorship()
    .forEach(jr -> joined.put(jr.get(User.class), jr.get(Article.class)));

assertThat(joined).isEqualTo(JoinRowMapperTest.getExpected());