import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Override
public Set<UUID> loadAllKeys() {
	// TODO define how many keys will be pre-loaded
	log.debug("loading all keys from table {}", tableName);
	Set<UUID> result = dbi.withHandle(new HandleCallback<Set<UUID>>() {
		@Override
		public Set<UUID> withHandle(Handle h) throws Exception {
			List<String> strResult = h.createQuery(String.format("select id from %s", tableName))
									  .map(new StringMapper()).list();
			Set<UUID> uResult = new HashSet<>();
			for (String uuid : strResult){
				uResult.add(UUID.fromString(uuid));
			}
			return uResult;
		}
	});
	log.debug("{} keys within table {} were loaded", result.size(), tableName);
	return result;	
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
public void updateUserPassword(int id, String oldPassword, String newPassword) {
    final String scrypt = SCryptUtil.scrypt(newPassword, 2 << 14, 8, 1);

    if (!PASSWORD_PATTERN.matcher(newPassword).matches()) {
        throw new RakamException("Password is not valid. Your password must contain at least one lowercase character, uppercase character and digit and be at least 8 characters. ", BAD_REQUEST);
    }

    if (config.getHashPassword()) {
        oldPassword = CryptUtil.encryptWithHMacSHA1(oldPassword, encryptionConfig.getSecretKey());
    }

    try (Handle handle = dbi.open()) {
        String hashedPass = handle.createQuery("SELECT password FROM web_user WHERE id = :id")
                .bind("id", id).map(StringMapper.FIRST).first();
        if (hashedPass == null) {
            throw new RakamException("User does not exist", BAD_REQUEST);
        }
        if (!SCryptUtil.check(oldPassword, hashedPass)) {
            throw new RakamException("Password is wrong", BAD_REQUEST);
        }
        handle.createStatement("UPDATE web_user SET password = :password WHERE id = :id")
                .bind("id", id)
                .bind("password", scrypt).execute();
    }
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
public void shouldCreate() {
  Map<String, AlarmSubExpression> subExpressions =
      ImmutableMap
          .<String, AlarmSubExpression>builder()
          .put(
              "4433",
              AlarmSubExpression
                  .of("avg(hpcs.compute{flavor_id=777, image_id=888, metric_name=cpu}) > 10"))
          .build();

  AlarmDefinition alarmA =
      repo.create("555", "2345", "90% CPU", null, "LOW",
          "avg(hpcs.compute{flavor_id=777, image_id=888, metric_name=cpu}) > 10", subExpressions,
          Arrays.asList("flavor_id", "image_id"), alarmActions, null, null);
  AlarmDefinition alarmB = repo.findById("555", alarmA.getId());

  assertEquals(alarmA, alarmB);

  // Assert that sub-alarm and sub-alarm-dimensions made it to the db
  assertEquals(
      handle.createQuery("select count(*) from sub_alarm_definition where id = 4433")
          .map(StringMapper.FIRST).first(), "1");
  assertEquals(
      handle.createQuery("select count(*) from sub_alarm_definition_dimension where sub_alarm_definition_id = 4433")
          .map(StringMapper.FIRST).first(), "3");
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Test
public void testFixturesArePresent() throws Exception
{
    DataSource ds = mysql.getDataSource();
    List<String> rs = new DBI(ds).withHandle(new HandleCallback<List<String>>()
    {
        @Override
        public List<String> withHandle(final Handle handle) throws Exception
        {
            return handle.createQuery("select name from something order by id")
                         .map(StringMapper.FIRST)
                         .list();
        }
    });

    assertThat(rs).containsExactly("Gene", "Brian");
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Test
public void testFixturesEstablished() throws Exception
{
    DataSource ds = mysql.getDataSource();
    List<String> rs = new DBI(ds).withHandle(new HandleCallback<List<String>>()
    {
        @Override
        public List<String> withHandle(final Handle handle) throws Exception
        {
            return handle.createQuery("select name from something order by id")
                         .map(StringMapper.FIRST)
                         .list();
        }
    });

    assertThat(rs).containsExactly("Gene", "Brian");
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
public List<CopyRole> getAllChildCopyRoles(Long workId) {
    List<String> copyRoleCodes = new ArrayList<>();
    try (Handle h = graph.dbi().open()) {
        copyRoleCodes = h.createQuery(
                "SELECT DISTINCT p2.copyRole " +
                "FROM node v, flatedge e, flatedge e2, work p, work p2 " +
                "WHERE e.v_in = :workId " +
                " AND e.v_out = v.id " +
                " AND e.label = 'isPartOf' " +
                " AND p.id = v.id " +
                " AND p.type IN ('Work', 'Page', 'EADWork')" +
                " AND e2.v_in = p.id " +
                " AND e2.v_out = p2.id " +
                " AND e2.label = 'isCopyOf' ")
                .bind("workId", workId)
                .map(StringMapper.FIRST).list();
    }

    List<CopyRole> copyRoles = new ArrayList<CopyRole>();
    for (String code : copyRoleCodes) {
        copyRoles.add(CopyRole.fromString(code));
    }
    return copyRoles;
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
public List<CopyRole> getAllCopyRoles(List<Long> workIds){
    List<CopyRole> copyRoles = new ArrayList<>();
    if (CollectionUtils.isNotEmpty(workIds)){
        List<String> copyRoleCodes;
        try (Handle h = graph.dbi().open()) {
            copyRoleCodes = h.createQuery(
                    "select distinct copyRole " +
                            "from work p, flatedge e, node v " +
                            "where p.id = e.v_out and v.id = p.id " +
                            "and e.label = 'isCopyOf' and e.v_in in (" + Joiner.on(",").join(workIds) + ")")
                    .map(StringMapper.FIRST).list();
        }
        for (String code : copyRoleCodes) {
            CopyRole copyRole = CopyRole.fromString(code);
            if (copyRole != null){
                copyRoles.add(copyRole);
            }
        }
    }
    return copyRoles;
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@RequestMapping(method = RequestMethod.GET)
public String get() {
    String name;
    Handle handle = dbi.open();
    try {
        name = handle.createQuery("select description from my_test")
                .map(StringMapper.FIRST)
                .first();
    } finally {
        handle.close();
    }
    return name;
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
public Optional<String> revokeSingleToken(String accountId, String tokenLink) {
    return Optional.ofNullable(jdbi.withHandle(handle ->
            handle.createQuery("UPDATE tokens SET revoked=(now() at time zone 'utc') WHERE account_id=:accountId AND token_link=:tokenLink AND revoked IS NULL RETURNING to_char(revoked,'DD Mon YYYY')")
                    .bind("accountId", accountId)
                    .bind("tokenLink", tokenLink)
                    .map(StringMapper.FIRST)
                    .first()));
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
public java.util.Optional<String> lookupColumnForTokenTable(String column, String idKey, String idValue) {
    return java.util.Optional.ofNullable(jdbi.withHandle(handle ->
            handle.createQuery("SELECT " + column + " FROM tokens WHERE " + idKey + "=:placeholder")
                    .bind("placeholder", idValue)
                    .map(StringMapper.FIRST)
                    .first()));

}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Override
public Set<String> keySet() {
    final Handle handle = dbi.open();
    final Query<String> query = handle
            .createQuery(String.format("select %s from %s order by %s", keyColumnName, tableName, keyColumnName))
            .map(StringMapper.FIRST);

    return new IteratingSet<String>() {
        @Override
        public Iterator<String> createIterator() {
            return new QueryResultIterator<>(query, handle);
        }
    };
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Test
public void putStoresExtraColumns() {
    ExtraColumnsJdbcMap extraMap = new ExtraColumnsJdbcMap("map", "key", "value", serializer);
    SerializableThing thing = new SerializableThing(42);
    extraMap.put("thing", thing);
    int num = handle.createQuery("select num from map where key = ?")
            .bind(0, "thing")
            .map(IntegerMapper.FIRST).first();
    assertThat(num, equalTo(42));
    String str = handle.createQuery("select str from map where key = ?")
            .bind(0, "thing")
            .map(StringMapper.FIRST).first();
    assertThat(str, equalTo("value42"));
    assertThat(extraMap.get("thing"), equalTo(thing));
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Override
public Set<DetailRace> getRacesWithFrequencies() {
    try (Handle handle = dbi.open()) {
        return handle.createQuery("select distinct detail_race from race_freq")
            .map(StringMapper.FIRST)
            .list()
            .stream()
            .map(r -> DetailRace.valueOf(r))
            .collect(Collectors.toSet());
    }
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Override
public Map<String, Set<String>> getFamilyAlleleMap() {
    try (Handle handle = dbi.open()) {
        return StreamSupport.stream(handle.createQuery("select distinct allele from ("
        		+ " select allele from race_freq where locus='HLA-DPB1'"
        		+ " union select allele from allele_group where locus='HLA-DPB1'"
        		+ " union select allele from hla_g_group where locus='HLA-DPB1')")
            .map(StringMapper.FIRST)
            .spliterator(), false)
            .collect(Collectors.groupingBy(a -> a.substring(0, a.indexOf(":")), Collectors.toSet()));
    }
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
/** 
  * {@inheritDoc} 
  */
 @Override
 public String getGGroupForAllele(String allele) {
     try (Handle handle = dbi.open()) {
Matcher m = ALLELE_PATTERN.matcher(allele);
if (!m.matches()) return null;
String group = handle.createQuery("select g_group from hla_g_group where locus = :locus and allele = :allele")
                 .bind("locus", m.group("locus"))
                 .bind("allele", m.group("allele"))
                 .map(StringMapper.FIRST)
                 .first();
return (group == null) ? null : m.group("locus") + "*" + group;
     }
 }
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Override
public String getPGroupForAllele(String allele) {
	try (Handle handle = dbi.open()) {
		Matcher m = ALLELE_PATTERN.matcher(allele);
		if (!m.matches()) return null;
		String group = handle.createQuery("select p_group from hla_p_group where locus = :locus and allele = :allele")
				.bind("locus", m.group("locus"))
				.bind("allele", m.group("allele"))
				.map(StringMapper.FIRST)
				.first();
		return (group == null) ? null : m.group("locus") + "*" + group;
	}
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Override
public void process(Exchange e) throws Exception {
	final BigDecimal previousSeqNumber = e.getIn().getHeader(PREVIOUS_SEQ_NUMBER, BigDecimal.class);
	final BigDecimal latestSeqNumber = e.getIn().getHeader(LATEST_SEQ_NUMBER, BigDecimal.class);
	List<String> ids = dbi.withHandle(new HandleCallback<List<String>>() {
		@Override
		public List<String> withHandle(Handle handle) throws Exception {
			String sqlGetIdsSinceLastSeqNumber = 
					String.format("select distinct id from %s where seq_number between :previous_seq_number +1 and :latest_seq_number", 
							tablesMetadata.getUnitOfWorkTable());
			log.debug(sqlGetIdsSinceLastSeqNumber);
			return handle.createQuery(sqlGetIdsSinceLastSeqNumber)
					.bind("previous_seq_number", previousSeqNumber)
					.bind("latest_seq_number", latestSeqNumber)
					.map(StringMapper.FIRST)
					.list();
		}
	});
	List<UUID> uuids = Lists.transform(ids, new Function<String, UUID>() {
		@Override
		public UUID apply(String input) {
			return UUID.fromString((String) input);
		}
	});				
	e.getOut().setBody(uuids, List.class);
	e.getOut().setHeader(HOW_MANY_UOWS_FOUND, ids.size());
	e.getOut().setHeader(LATEST_SEQ_NUMBER, latestSeqNumber);
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Override
public Set<String> getProjects() {
    try (Handle handle = dbi.open()) {
        return ImmutableSet.copyOf(
                handle.createQuery("select name from project")
                        .map(StringMapper.FIRST).iterator());
    }
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@Override
public List<String> types(int project) {
    try (Handle handle = dbi.open()) {
        return handle.createQuery("SELECT DISTINCT report_type FROM custom_reports WHERE project_id = :project")
                .bind("project", project)
                .map(StringMapper.FIRST).list();
    }
}
 

import org.skife.jdbi.v2.util.StringMapper; //导入依赖的package包/类
@JsonRequest
@ProtectEndpoint(requiresProject = false)
@ApiOperation(value = "List cluster", authorizations = @Authorization(value = "read_key"))
@Path("/list")
@GET
public List<String> list(@javax.inject.Named("user_id") Project project) {
    try (Handle handle = dbi.open()) {
        return handle.createQuery("SELECT api_url FROM rakam_cluster WHERE user_id = :userId")
                .bind("userId", project.userId).map(StringMapper.FIRST).list();
    }
}