Verificación de un valor int nulo desde un ResultSet de Java

En Java, estoy tratando de probar un valor nulo, desde un ResultSet, donde la columna se está convirtiendo en un 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");
  }
}

Desde el fragmento de código anterior, ¿hay una mejor manera de hacer esto, y supongo que la segunda prueba wasNull () es redundante?

Edúcanos y gracias

El valor predeterminado para ResultSet.getIntcuando el valor del campo es NULLdevolver 0, que también es el valor predeterminado para su iValdeclaración. En cuyo caso su prueba es completamente redundante.

Si realmente desea hacer algo diferente si el valor del campo es NULL, sugiero:

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 a continuación; el código OP como está escrito no se compilaría porque iValno está inicializado)

Otra solución:

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

Creo que es redundante. rs.getObject("ID_PARENT")debería devolver un Integerobjeto o null, si el valor de la columna realmente fuera NULL. Por lo tanto, incluso debería ser posible hacer 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
  }      
}

Simplemente verifique si el campo está nullutilizando o no ResultSet#getObject(). Sustituya -1con el valor de mayúsculas y minúsculas que desee.

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

O bien, si puede garantizar que utiliza el tipo de columna de base de datos correcto para que ResultSet#getObject()realmente devuelva un Integer(y, por lo tanto Long, no , Shorto Byte), también puede simplemente escribirlo en un Integer.

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

AFAIK simplemente puedes usar

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

incluso si es NULL.

Solo una actualización con Java Generics.

Podría crear un método de utilidad para recuperar un valor opcional de cualquier tipo de Java de un ResultSet dado, previamente emitido.

Desafortunadamente, getObject (columnName, Class) no devuelve nulo, pero el valor predeterminado para un tipo de Java dado, por lo que se requieren 2 llamadas

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;
}

En este ejemplo, su código podría verse a continuación:

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

Feliz de recibir comentarios

Puede llamar a este método usando resultSet y el nombre de la columna que tiene el tipo Number. Devolverá el valor entero o nulo. No habrá ceros devueltos por valor vacío en la base de datos

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

Con java 8 puedes hacer esto:

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

En ese caso, se asegura de que nVal será nulo (y no cero) si el valor de SQL es NULL

Para mayor comodidad, puede crear una clase de contenedor alrededor de ResultSet que devuelva valores nulos cuando ResultSetnormalmente no lo haría.

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;
    }

    // ...

}

Otra buena manera de verificar, si tiene control del SQL, es agregar un valor predeterminado en la consulta para su columna int. Luego solo verifique ese valor.

por ejemplo, para una base de datos Oracle, use NVL

SELECT NVL(ID_PARENT, -999) FROM TABLE_NAME;

Entonces revisa

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

Por supuesto, esto también se da por supuesto que hay un valor que normalmente no se encontraría en la columna.