import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
public Jdbi build(Environment environment,
                  PooledDataSourceFactory configuration,
                  String name) {
    ManagedDataSource dataSource = configuration.build(environment.metrics(), name);
    String validationQuery = configuration.getValidationQuery();
    Jdbi jdbi = Jdbi.create(dataSource);
    jdbi.setTimingCollector(new InstrumentedTimingCollector(environment.metrics(), nameStrategy));
    jdbi.installPlugins();

    environment.lifecycle().manage(dataSource);
    environment.healthChecks().register(name, new JdbiHealthCheck(
            environment.getHealthCheckExecutorService(),
            configuration.getValidationQueryTimeout().orElseGet(() -> Duration.seconds(5)),
            jdbi, validationQuery));

    return jdbi;
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Test
public void test() throws Exception {
  Jdbi jdbi = Jdbi.create(ds.getDataSource());

  try (Handle h = jdbi.open()) {
    h.execute("create table contacts (id int primary key, name varchar(100))");

    h.execute("insert into contacts (id, name) values (?, ?)", 1, "Alice");
    h.execute("insert into contacts (id, name) values (?, ?)", 2, "Bob");

    List<String> names = h.createQuery("select name from contacts order by id")
        .mapTo(String.class)
        .list();
    assertThat(names)
        .containsExactly("Alice", "Bob");

    String name = h.createQuery("select name from contacts where id = :id")
        .bind("id", 1)
        .mapTo(String.class)
        .findOnly();
    assertThat(name)
        .isEqualTo("Alice");

  }
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Override
protected Statement classBlock(RunNotifier notifier) {
    final Statement statement = super.classBlock(notifier);
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            // Open a new handle for every test
            // It affords to avoid creating a static state which makes tests more independent
            JditProperties jditProperties = klass.getAnnotation(JditProperties.class);
            Jdbi dbi = jditProperties != null ? DBIContextFactory.getDBI(jditProperties.value()) : DBIContextFactory.getDBI();
            try (Handle handle = dbi.open()) {
                injector = new TestObjectsInjector(dbi, handle);
                databaseMaintenance = DatabaseMaintenanceFactory.create(handle);
                dataSetInjector = new DataSetInjector(new DataMigration(handle));
                statement.evaluate();
            }
        }
    };
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Test
public void configureWithCallback() throws Exception {
  new MockUnit(Env.class, Config.class, Binder.class, JdbiPlugin.class)
      .expect(configure)
      .expect(unit -> {
        Jdbi jdbi = unit.get(Jdbi.class);
        expect(jdbi.installPlugin(unit.get(JdbiPlugin.class))).andReturn(jdbi);
      })
      .run(unit -> {
        new Jdbi3()
            .doWith(jdbi -> {
              jdbi.installPlugin(unit.get(JdbiPlugin.class));
            })
            .configure(unit.get(Env.class), unit.get(Config.class), unit.get(Binder.class));
      });
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Test
public void inClause() {
  Jdbi jdbi = Jdbi.create("jdbc:h2:mem:test");
  List<String> names = jdbi.withHandle(h -> {
    h.createUpdate("CREATE TABLE USER (id INTEGER PRIMARY KEY, name VARCHAR)")
        .execute();
    h.createUpdate("INSERT INTO USER(id, name) VALUES (:id, :name)")
        .bind("id", 1)
        .bind("name", "Pedro Picapiedra")
        .execute();
    h.createUpdate("INSERT INTO USER(id, name) VALUES (:id, :name)")
        .bind("id", 2)
        .bind("name", "Pablo Marmol")
        .execute();

    return h.createQuery("select name from USER where id in (<id>)")
        .bindList("id", 1, 2)
        .mapTo(String.class)
        .list();
  });

  assertEquals(2, names.size());
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Override
public void load(Undertow.Builder builder, DeploymentContext deploymentContext) throws IOException {
    log.info( "Creating users and roles..." );
    val script = SystemResource.readFileAsString( "tables.sql", "UTF-8" );
    val jdbi = Jdbi.create( dataSource );
    try ( val handle = jdbi.open() ) {
        handle.useTransaction( h -> h.createScript( script ).execute() );
    }
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
public static void main(String[] args) {
    Jdbi dbi = Jdbi.create("jdbc:sqlite:behemoth.db");
    String installScript = ClasspathSqlLocator.findSqlOnClasspath(InitDatabase.class.getName() + "_install");
    dbi.useHandle(hnd -> {
        int totalExecuted = 0;
        int[] rowsExecuted = hnd.createScript(installScript).execute();
        for (int rows : rowsExecuted) {
            totalExecuted += rows;
        }
        System.out.println("Executed: " + totalExecuted);
    });

}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
public JdbiDynamicEnumCache(Jdbi conn, Class<T> clazz, String tableName, BiFunction<Long, String, T> typeCodeFactory) {
    super(clazz);
    conn.useHandle(handle -> {
        Query q = handle.createQuery("SELECT id, name FROM " + tableName);
        ResultIterable<T> tcIter = q.map((rs, ctx) -> typeCodeFactory.apply(rs.getLong("id"),
                                    rs.getString("name")));
        tcIter.forEach(this::add);
    });
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Test
public void test() throws Exception {
  Jdbi jdbi = Jdbi.create(ds.getDataSource());
  jdbi.registerRowMapper(BeanMapper.factory(Account.class));
  jdbi.registerColumnMapper(new MoneyMapper());
  jdbi.registerArgument(new MoneyArgumentFactory());

  try (Handle h = jdbi.open()) {
    Money tenDollars = Money.of(USD, 10);
    Money fiveDollars = Money.of(USD, 5);

    h.execute("create table accounts (id int primary key, name varchar(100), balance decimal)");

    h.execute("insert into accounts (id, name, balance) values (?, ?, ?)", 1, "Alice", tenDollars);
    h.execute("insert into accounts (id, name, balance) values (?, ?, ?)", 2, "Bob", fiveDollars);

    List<Account> list = h.createQuery("select * from accounts order by id")
        .mapTo(Account.class)
        .list();
    assertThat(list)
        .extracting(Account::getId, Account::getName, Account::getBalance)
        .containsExactly(tuple(1, "Alice", tenDollars),
                         tuple(2, "Bob", fiveDollars));

    Account bob = h.createQuery("select * from accounts where id = :id")
        .bind("id", 2)
        .mapTo(Account.class)
        .findOnly();
    assertThat(bob)
        .extracting(Account::getId, Account::getName, Account::getBalance)
        .containsExactly(2, "Bob", fiveDollars);
  }
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Test
public void test() throws Exception {
  Jdbi jdbi = Jdbi.create(ds.getDataSource());
  jdbi.installPlugin(new SqlObjectPlugin());

  jdbi.useExtension(AccountDao.class, dao -> {
    Money tenDollars = Money.of(USD, 10);
    Money fiveDollars = Money.of(USD, 5);

    dao.createTable();
    dao.insert(new Account(1, "Alice", tenDollars));
    dao.insert(new Account(2, "Bob", fiveDollars));

    assertThat(dao.list())
        .extracting(Account::getId, Account::getName, Account::getBalance)
        .containsExactly(tuple(1, "Alice", tenDollars),
                         tuple(2, "Bob", fiveDollars));

    assertThat(dao.getById(2))
        .extracting(Account::getId, Account::getName, Account::getBalance)
        .containsExactly(2, "Bob", fiveDollars);

    dao.update(new Account(2, "Robert", tenDollars));

    assertThat(dao.getById(2))
        .extracting(Account::getId, Account::getName, Account::getBalance)
        .containsExactly(2, "Robert", tenDollars);
  });
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Test
public void test() throws Exception {
  Jdbi jdbi = Jdbi.create(ds.getDataSource());

  try (Handle h = jdbi.open()) {
    h.execute("create table contacts (id int primary key, name varchar(100))");

    h.execute("insert into contacts (id, name) values (?, ?)", 1, "Alice");
    h.execute("insert into contacts (id, name) values (?, ?)", 2, "Bob");

    List<Contact> list = h.createQuery("select * from contacts order by id")
        .map(new ContactMapper())
        .list();
    assertThat(list)
        .extracting(Contact::getId, Contact::getName)
        .containsExactly(tuple(1, "Alice"),
                         tuple(2, "Bob"));

    Contact bob = h.createQuery("select * from contacts where id = :id")
        .bind("id", 2)
        .map(new ContactMapper())
        .findOnly();
    assertThat(bob)
        .extracting(Contact::getId, Contact::getName)
        .containsExactly(2, "Bob");
  }
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Test
public void test() throws Exception {
  Jdbi jdbi = Jdbi.create(ds.getDataSource());
  jdbi.registerRowMapper(new ContactMapper());

  try (Handle h = jdbi.open()) {
    h.execute("create table contacts (id int primary key, name varchar(100))");

    h.execute("insert into contacts (id, name) values (?, ?)", 1, "Alice");
    h.execute("insert into contacts (id, name) values (?, ?)", 2, "Bob");

    List<Contact> list = h.createQuery("select * from contacts order by id")
        .mapTo(Contact.class)
        .list();
    assertThat(list)
        .extracting(Contact::getId, Contact::getName)
        .containsExactly(tuple(1, "Alice"),
                         tuple(2, "Bob"));

    Contact bob = h.createQuery("select * from contacts where id = :id")
        .bind("id", 2)
        .mapTo(Contact.class)
        .findOnly();
    assertThat(bob)
        .extracting(Contact::getId, Contact::getName)
        .containsExactly(2, "Bob");
  }
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
public void before() throws Exception {
    dbi = Jdbi.create(uri);
    if (installPlugins) {
        dbi.installPlugins();
    }
    plugins.forEach(dbi::installPlugin);
    sharedHandle = dbi.open();
    con = sharedHandle.getConnection();
    try (Statement s = con.createStatement()) {
        s.execute("create table people(id identity primary key, firstName varchar(50), lastName varchar(50), email varchar(255), created timestamp, modified timestamp);");
    }
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
/**
 * Inject a DBI instance to a field with {@link DBIInstance} annotation.
 *
 * @param test  current test
 * @param field current field
 * @throws IllegalAccessException reflection error
 */
private void handleDbiInstance(Object test, Field field) throws IllegalAccessException {
    if (!field.getType().equals(Jdbi.class)) {
        throw new IllegalArgumentException("Unable inject a DBI instance to " +
                "a field with type " + field.getType());
    }
    if (Modifier.isStatic(field.getModifiers())) {
        throw new IllegalArgumentException("Unable inject a DBI instance to a static field");
    }
    field.setAccessible(true);
    field.set(test, dbi);
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Override
public Jdbi createDBI(Properties properties) {
    Jdbi dbi = Jdbi.create(properties.getProperty("db.url"), properties.getProperty("db.username"),
            properties.getProperty("db.password"));
    dbi.installPlugins();
    return dbi;
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
/**
 * Create and configure a {@link Jdbi} instance from the properties
 * The DB is created during the first connection.
 *
 * @param properties configuration of DB
 * @return a new {@link Jdbi} instance for performing database access
 */
private Jdbi createDBI(Properties properties) {
    try {
        DBIFactory dbiFactory = (DBIFactory) Class.forName(properties.getProperty("dbi.factory"))
                .newInstance();
        return dbiFactory.createDBI(properties);
    } catch (Exception e) {
        throw new IllegalStateException("Unable instantiate DBI Factory", e);
    }
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Test
public void testMapToDbObject() throws Exception {
    Jdbi dbi = Jdbi.create(DbHelper.getHsqlDataSource());
    dbi.installPlugins();
    Handle handle = dbi.open();
    try {
        DbObject dbObject = handle.createQuery(DbHelper.TEST_DB_OBJECT_QUERY).mapTo(DbObject.class).findFirst().get();
        DbHelper.assertDbObjectMapping(dbObject);
    } finally {
        handle.close();
    }
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Test
public void openHandle() throws Exception {
  new MockUnit(Handle.class, Request.class, Response.class, Route.Chain.class, Jdbi.class, Handle.class)
      .expect(unit -> {
        Handle handle = unit.get(Handle.class);
        expect(handle.setReadOnly(true)).andReturn(handle);
        expect(handle.begin()).andReturn(handle);

        Request request = unit.get(Request.class);
        expect(request.set(Key.get(Handle.class), handle)).andReturn(request);

        Response response = unit.get(Response.class);
        response.after(isA(CommitTransaction.class));
        response.complete(isA(RollbackTransaction.class));
        response.complete(isA(CloseHandle.class));

        Route.Chain chain = unit.get(Route.Chain.class);
        chain.next(request, response);

        Jdbi jdbi = unit.get(Jdbi.class);
        expect(jdbi.open()).andReturn(handle);
      })
      .run(unit -> {
        TransactionalRequest req = new TransactionalRequest();
        req.doWith(h -> {
          h.setReadOnly(true);
        });
        new OpenHandle(unit.get(Jdbi.class), req)
            .handle(unit.get(Request.class), unit.get(Response.class),
                unit.get(Route.Chain.class));
      });
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
@Provides
@Singleton
Jdbi dbi(DataSource dataSource) {
    return Jdbi.create(dataSource);
}
 

import org.jdbi.v3.core.Jdbi; //导入依赖的package包/类
public SqlliteDatetimeSource(Jdbi dbi) {
    this.dbi = dbi;
}