Verificando um valor int nulo de um Java ResultSet

Em Java, estou tentando testar um valor nulo, de um ResultSet, onde a coluna está sendo convertida em um tipo int primitivo .

int iVal;
ResultSet rs = magicallyAppearingStmt.executeQuery(query);
if (rs.next()) {
  if (rs.getObject("ID_PARENT") != null && !rs.wasNull()) {
    iVal = rs.getInt("ID_PARENT");
  }
}

No fragmento de código acima, existe uma maneira melhor de fazer isso e suponho que o segundo teste wasNull () seja redundante?

Eduque-nos e obrigado

O padrão para ResultSet.getIntquando o valor do campo é NULLretornar 0, que também é o valor padrão para sua iValdeclaração. Nesse caso, seu teste é completamente redundante.

Se você realmente deseja fazer algo diferente se o valor do campo for NULL, sugiro:

int iVal = 0;
ResultSet rs = magicallyAppearingStmt.executeQuery(query);
if (rs.next()) {
    iVal = rs.getInt("ID_PARENT");
    if (rs.wasNull()) {
        // handle NULL field value
    }
}

(Editado como @martin comenta abaixo; o código OP conforme escrito não seria compilado porque iValnão foi inicializado)

Outra solução:

public class DaoTools {
    static public Integer getInteger(ResultSet rs, String strColName) throws SQLException {
        int nValue = rs.getInt(strColName);
        return rs.wasNull() ? null : nValue;
    }
}

Eu acho que é redundante. rs.getObject("ID_PARENT")deve retornar um Integerobjeto ou null, se o valor da coluna realmente era NULL. Portanto, deve ser possível fazer algo como:

if (rs.next()) {
  Integer idParent = (Integer) rs.getObject("ID_PARENT");
  if (idParent != null) {
    iVal = idParent; // works for Java 1.5+
  } else {
    // handle this case
  }      
}

Basta verificar se o campo está nullou não em uso ResultSet#getObject(). Substitua -1pelo valor de nulo desejado.

int foo = resultSet.getObject("foo") != null ? resultSet.getInt("foo") : -1;

Ou, se você pode garantir que você use o tipo de coluna DB direita para que ResultSet#getObject()realmente retorna um Integer(e, portanto, não Long, Shortou Byte), então você também pode simplesmente typecast-lo a um Integer.

Integer foo = (Integer) resultSet.getObject("foo");

AFAIK você pode simplesmente usar

iVal = rs.getInt("ID_PARENT");
if (rs.wasNull()) {
  // do somthing interesting to handle this situation
}

mesmo que seja NULL.

Apenas uma atualização com o Java Generics.

Você pode criar um método utilitário para recuperar um valor opcional de qualquer tipo Java de um determinado ResultSet, convertido anteriormente.

Infelizmente, getObject (columnName, Class) não retorna nulo, mas o valor padrão para determinado tipo Java, portanto, são necessárias 2 chamadas

public <T> T getOptionalValue(final ResultSet rs, final String columnName, final Class<T> clazz) throws SQLException {
    final T value = rs.getObject(columnName, clazz);
    return rs.wasNull() ? null : value;
}

Neste exemplo, seu código pode ser parecido abaixo:

final Integer columnValue = getOptionalValue(rs, Integer.class);
if (columnValue == null) {
    //null handling
} else {
    //use int value of columnValue with autoboxing
}

É um prazer receber feedback

Você pode chamar esse método usando resultSet e o nome da coluna com o tipo Number. Ele retornará o valor Inteiro ou nulo. Não haverá zeros retornados para o valor vazio no banco de dados

private Integer getIntWithNullCheck(ResultSet rset, String columnName) {
    try {
        Integer value = rset.getInt(columnName);
        return rset.wasNull() ? null : value;
    } catch (Exception e) {
        return null;
    }
}

Com o java 8, você pode fazer isso:

Long nVal = Optional.ofNullable(resultSet.getBigDecimal("col_name"))
                    .map(BigDecimal::longValue).orElse(null));

Nesse caso, você garante que o nVal será nulo (e não zero) se o valor SQL for NULL

Por conveniência, você pode criar uma classe de wrapper em torno de ResultSet que retorne valores nulos quando ResultSetnormalmente não.

public final class ResultSetWrapper {

    private final ResultSet rs;

    public ResultSetWrapper(ResultSet rs) {
        this.rs = rs;
    }

    public ResultSet getResultSet() {
        return rs;
    }

    public Boolean getBoolean(String label) throws SQLException {
        final boolean b = rs.getBoolean(label);
        if (rs.wasNull()) {
            return null;
        }
        return b;
    }

    public Byte getByte(String label) throws SQLException {
        final byte b = rs.getByte(label);
        if (rs.wasNull()) {
            return null;
        }
        return b;
    }

    // ...

}

Outra boa maneira de verificar, se você controla o SQL, é adicionar um valor padrão na própria consulta para sua coluna int. Em seguida, basta verificar esse valor.

por exemplo, para um banco de dados Oracle, use NVL

SELECT NVL(ID_PARENT, -999) FROM TABLE_NAME;

então verifique

if (rs.getInt('ID_PARENT') != -999)
{
}

Obviamente, isso também pressupõe que exista um valor que normalmente não seria encontrado na coluna.