Consulta Jdbctemplate para string: EmptyResultDataAccessException: Tamanho de resultado incorreto: esperado 1, real 0

Estou usando o Jdbctemplate para recuperar um único valor String do banco de dados. Aqui está meu método.

    public String test() {
        String cert=null;
        String sql = "select ID_NMB_SRZ from codb_owner.TR_LTM_SLS_RTN 
             where id_str_rt = '999' and ID_NMB_SRZ = '60230009999999'";
        cert = (String) jdbc.queryForObject(sql, String.class); 
        return cert;
    }

No meu cenário, é totalmente possível NÃO obter uma resposta em minha consulta, então minha pergunta é como faço para contornar a seguinte mensagem de erro.

EmptyResultDataAccessException: Incorrect result size: expected 1, actual 0

Parece-me que devo apenas obter um valor nulo em vez de lançar uma exceção. Como posso consertar isso? Desde já, obrigado.

Em JdbcTemplate, queryForInt, queryForLong, queryForObjecttodos esses métodos espera que consulta executada irá retornar uma e apenas uma linha. Se você não obtiver nenhuma linha ou mais de uma linha, isso resultará em IncorrectResultSizeDataAccessException. Agora, a maneira correta é não capturar essa exceção ou EmptyResultDataAccessException, mas certificar-se de que a consulta que você está usando deve retornar apenas uma linha. Se isso não for possível, use o querymétodo.

List<String> strLst  = getJdbcTemplate().query(sql,new RowMapper {

  public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
        return rs.getString(1);
  }

});

if ( strLst.isEmpty() ){
  return null;
}else if ( strLst.size() == 1 ) { // list contains exactly 1 element
  return strLst.get(0);
}else{  // list contains more than 1 elements
  //your wish, you can either throw the exception or return 1st element.    
}

Você também pode usar um em ResultSetExtractorvez de a RowMapper. Ambos são tão fáceis um quanto o outro, a única diferença é você ligar ResultSet.next().

public String test() {
    String sql = "select ID_NMB_SRZ from codb_owner.TR_LTM_SLS_RTN "
                 + " where id_str_rt = '999' and ID_NMB_SRZ = '60230009999999'";
    return jdbc.query(sql, new ResultSetExtractor<String>() {
        @Override
        public String extractData(ResultSet rs) throws SQLException,
                                                       DataAccessException {
            return rs.next() ? rs.getString("ID_NMB_SRZ") : null;
        }
    });
}

O ResultSetExtractortem a vantagem adicional de poder lidar com todos os casos em que há mais de uma linha ou nenhuma linha retornada.

ATUALIZAÇÃO : Vários anos depois, tenho alguns truques para compartilhar. JdbcTemplatefunciona muito bem com java 8 lambdas, para os quais os exemplos a seguir foram projetados, mas você pode facilmente usar uma classe estática para fazer o mesmo.

Embora a questão seja sobre tipos simples, esses exemplos servem como um guia para o caso comum de extração de objetos de domínio.

Primeiramente. Vamos supor que você tenha um objeto de conta com duas propriedades para simplificar Account(Long id, String name). Você provavelmente gostaria de ter um RowMapperpara este objeto de domínio.

private static final RowMapper<Account> MAPPER_ACCOUNT =
        (rs, i) -> new Account(rs.getLong("ID"),
                               rs.getString("NAME"));

Agora você pode usar este mapeador diretamente em um método para mapear Accountobjetos de domínio de uma consulta ( jté uma JdbcTemplateinstância).

public List<Account> getAccounts() {
    return jt.query(SELECT_ACCOUNT, MAPPER_ACCOUNT);
}

Ótimo, mas agora queremos nosso problema original e usamos minha solução original reutilizando o RowMapperpara realizar o mapeamento para nós.

public Account getAccount(long id) {
    return jt.query(
            SELECT_ACCOUNT,
            rs -> rs.next() ? MAPPER_ACCOUNT.mapRow(rs, 1) : null,
            id);
}

Ótimo, mas esse é um padrão que você pode e deseja repetir. Portanto, você pode criar um método de fábrica genérico para criar um novo ResultSetExtractorpara a tarefa.

public static <T> ResultSetExtractor singletonExtractor(
        RowMapper<? extends T> mapper) {
    return rs -> rs.next() ? mapper.mapRow(rs, 1) : null;
}

Criar um ResultSetExtractoragora se torna trivial.

private static final ResultSetExtractor<Account> EXTRACTOR_ACCOUNT =
        singletonExtractor(MAPPER_ACCOUNT);

public Account getAccount(long id) {
    return jt.query(SELECT_ACCOUNT, EXTRACTOR_ACCOUNT, id);
}

Espero que isso ajude a mostrar que agora você pode combinar facilmente partes de uma maneira poderosa para tornar seu domínio mais simples.

ATUALIZAÇÃO 2 : Combine com um Opcional para valores opcionais em vez de nulo.

public static <T> ResultSetExtractor<Optional<T>> singletonOptionalExtractor(
        RowMapper<? extends T> mapper) {
    return rs -> rs.next() ? Optional.of(mapper.mapRow(rs, 1)) : Optional.empty();
}

Que agora, quando usado, poderia ter o seguinte:

private static final ResultSetExtractor<Optional<Double>> EXTRACTOR_DISCOUNT =
        singletonOptionalExtractor(MAPPER_DISCOUNT);

public double getDiscount(long accountId) {
    return jt.query(SELECT_DISCOUNT, EXTRACTOR_DISCOUNT, accountId)
            .orElse(0.0);
}

Essa não é uma boa solução porque você está contando com exceções para o fluxo de controle. Na sua solução é normal obter exceções, é normal tê-las no log.

public String test() {
    String sql = "select ID_NMB_SRZ from codb_owner.TR_LTM_SLS_RTN where id_str_rt = '999' and ID_NMB_SRZ = '60230009999999'";
    List<String> certs = jdbc.queryForList(sql, String.class); 
    if (certs.isEmpty()) {
        return null;
    } else {
        return certs.get(0);
    }
}

Ok, eu descobri. Acabei de envolvê-lo em um try catch e enviar de volta null.

    public String test() {
            String cert=null;
            String sql = "select ID_NMB_SRZ from codb_owner.TR_LTM_SLS_RTN 
                     where id_str_rt = '999' and ID_NMB_SRZ = '60230009999999'";
            try {
                Object o = (String) jdbc.queryForObject(sql, String.class);
                cert = (String) o;
            } catch (EmptyResultDataAccessException e) {
                e.printStackTrace();
            }
            return cert;
    }

Na verdade, você pode brincar JdbcTemplatee personalizar seu próprio método como preferir. Minha sugestão é fazer algo assim:

public String test() {
    String cert = null;
    String sql = "select ID_NMB_SRZ from codb_owner.TR_LTM_SLS_RTN
        where id_str_rt = '999' and ID_NMB_SRZ = '60230009999999'";
    ArrayList<String> certList = (ArrayList<String>) jdbc.query(
        sql, new RowMapperResultSetExtractor(new UserMapper()));
    cert =  DataAccessUtils.singleResult(certList);

    return cert;
}

Funciona como o original jdbc.queryForObject, mas sem throw new EmptyResultDataAccessExceptionquando size == 0.

Como retornar um valor nulo quando não há dados é algo que eu quero fazer com frequência ao usar queryForObject, achei útil estender JdbcTemplate e adicionar um método queryForNullableObject semelhante ao abaixo.

public class JdbcTemplateExtended extends JdbcTemplate {

    public JdbcTemplateExtended(DataSource datasource){
        super(datasource);
    }

    public <T> T queryForNullableObject(String sql, RowMapper<T> rowMapper) throws DataAccessException {
        List<T> results = query(sql, rowMapper);

        if (results == null || results.isEmpty()) {
            return null;
        }
        else if (results.size() > 1) {
            throw new IncorrectResultSizeDataAccessException(1, results.size());
        }
        else{
            return results.iterator().next();
        }
    }

    public <T> T queryForNullableObject(String sql, Class<T> requiredType) throws DataAccessException {
        return queryForObject(sql, getSingleColumnRowMapper(requiredType));
    }

}

Agora você pode usar isso em seu código da mesma maneira que usou queryForObject

String result = queryForNullableObject(queryString, String.class);

Gostaria de saber se mais alguém acha que isso é uma boa ideia.

Usando Java 8 ou superior, você pode usar um Optional e Java Streams.

Então você pode simplesmente usar o JdbcTemplate.queryForList()método, criar um Stream e usar o Stream.findFirst()que retornará o primeiro valor do Stream ou um vazio Optional:

public Optional<String> test() {
    String sql = "select ID_NMB_SRZ from codb_owner.TR_LTM_SLS_RTN where id_str_rt = '999' and ID_NMB_SRZ = '60230009999999'";
    return jdbc.queryForList(sql, String.class)
            .stream().findFirst();
}

Para melhorar o desempenho da consulta, você pode anexar LIMIT 1à sua consulta, de forma que não mais de 1 item seja transferido do banco de dados.

Você pode usar uma função de grupo para que sua consulta sempre retorne um resultado. ie

MIN(ID_NMB_SRZ)

No Postgres, você pode fazer com que quase qualquer consulta de valor único retorne um valor ou nulo envolvendo-o:

SELECT (SELECT <query>) AS value

e, portanto, evita a complexidade do chamador.

Já que getJdbcTemplate (). QueryForMap espera tamanho mínimo de um, mas quando retorna null mostra EmptyResultDataAccesso corrige dis quando pode usar a lógica abaixo

Map<String, String> loginMap =null;
try{
    loginMap = getJdbcTemplate().queryForMap(sql, new Object[] {CustomerLogInInfo.getCustLogInEmail()});
}
catch(EmptyResultDataAccessException ex){
    System.out.println("Exception.......");
    loginMap =null;
}
if(loginMap==null || loginMap.isEmpty()){
    return null;
}
else{
    return loginMap;
}

Eu lidei com isso antes e havia postado nos fóruns da primavera.

http://forum.spring.io/forum/spring-projects/data/123129-frustrated-with-emptyresultdataaccessexception

O conselho que recebemos foi usar um tipo de SQlQuery. Aqui está um exemplo do que fizemos ao tentar obter um valor de um banco de dados que pode não estar lá.

@Component
public class FindID extends MappingSqlQuery<Long> {

        @Autowired
        public void setDataSource(DataSource dataSource) {

                String sql = "Select id from address where id = ?";

                super.setDataSource(dataSource);

                super.declareParameter(new SqlParameter(Types.VARCHAR));

                super.setSql(sql);

                compile();
        }

        @Override
        protected Long mapRow(ResultSet rs, int rowNum) throws SQLException {
                return rs.getLong(1);
        }

No DAO então apenas ligamos ...

Long id = findID.findObject(id);

Não está claro no desempenho, mas funciona e é legal.

Para Byron, você pode tentar isso ..

public String test(){
                String sql = "select ID_NMB_SRZ from codb_owner.TR_LTM_SLS_RTN 
                     where id_str_rt = '999' and ID_NMB_SRZ = '60230009999999'";
                List<String> li = jdbcTemplate.queryForList(sql,String.class);
                return li.get(0).toString();
        }

fazer

    jdbcTemplate.queryForList(sql, String.class)

trabalho, certifique-se de que seu jdbcTemplate é do tipo

    org.springframework.jdbc.core.JdbcTemplate

Podemos usar query em vez de queryForObject, a principal diferença entre query e queryForObject é que a lista de retorno da consulta do Object (com base no tipo de retorno do Row mapper) e essa lista pode estar vazia se nenhum dado for recebido do banco de dados, enquanto queryForObject sempre espera que apenas um único objeto seja buscado do banco de dados nem nulo nem linhas múltiplas e, caso o resultado seja vazio, queryForObject lança EmptyResultDataAccessException. Eu escrevi um código usando consulta que superará o problema de EmptyResultDataAccessException em caso de resultado nulo.

----------


public UserInfo getUserInfo(String username, String password) {
      String sql = "SELECT firstname, lastname,address,city FROM users WHERE id=? and pass=?";
      List<UserInfo> userInfoList = jdbcTemplate.query(sql, new Object[] { username, password },
              new RowMapper<UserInfo>() {
                  public UserInfo mapRow(ResultSet rs, int rowNum) throws SQLException {
                      UserInfo user = new UserInfo();
                      user.setFirstName(rs.getString("firstname"));
                      user.setLastName(rs.getString("lastname"));
                      user.setAddress(rs.getString("address"));
                      user.setCity(rs.getString("city"));

                      return user;
                  }
              });

      if (userInfoList.isEmpty()) {
          return null;
      } else {
          return userInfoList.get(0);
      }
  }

IMHO retornar um nullé uma solução ruim porque agora você tem o problema de enviar e interpretar no (provável) cliente front-end. Eu tive o mesmo erro e resolvi simplesmente retornando a List<FooObject>. eu useiJDBCTemplate.query() .

No front end (cliente Web Angular), eu simplesmente examino a lista e, se ela estiver vazia (de comprimento zero), a considero como nenhum registro encontrado.

Acabei de pegar esta "EmptyResultDataAccessException"

public Myclass findOne(String id){
    try {
        Myclass m = this.jdbcTemplate.queryForObject(
                "SELECT * FROM tb_t WHERE id = ?",
                new Object[]{id},
                new RowMapper<Myclass>() {
                    public Myclass mapRow(ResultSet rs, int rowNum) throws SQLException {
                        Myclass m = new Myclass();
                        m.setName(rs.getString("name"));
                        return m;
                    }
                });
        return m;
    } catch (EmptyResultDataAccessException e) { // result.size() == 0;
        return null;
    }
}

então você pode verificar:

if(m == null){
    // insert operation.
}else{
    // update operation.
}