Verifica di un valore int nullo da un ResultSet Java

In Java sto cercando di verificare un valore null, da un ResultSet, in cui la colonna viene eseguita il cast su 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");
  }
}

Dal frammento di codice sopra, c'è un modo migliore per farlo e suppongo che il secondo test wasNull () sia ridondante?

Educaci e grazie

L'impostazione predefinita per ResultSet.getIntquando NULLdeve essere restituito il valore del campo 0, che è anche il valore predefinito per la iValdichiarazione. Nel qual caso il test è completamente ridondante.

Se in realtà vuoi fare qualcosa di diverso se il valore del campo è NULL, ti suggerisco:

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

(Modificato come commenti @martin di seguito; il codice OP così come scritto non verrà compilato perché iValnon inizializzato)

Un'altra soluzione:

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

Penso che sia ridondante. rs.getObject("ID_PARENT")dovrebbe restituire un Integeroggetto oppure null, se il valore della colonna era effettivamente NULL. Quindi dovrebbe anche essere possibile fare qualcosa del tipo:

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

Controlla se il campo è nullo meno in uso ResultSet#getObject(). Sostituisci -1con qualunque valore di maiuscolo che desideri.

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

Oppure, se puoi garantire di utilizzare il giusto tipo di colonna DB in modo che ResultSet#getObject()restituisca davvero un Integer(e quindi no Long, Shorto Byte), puoi anche semplicemente inserirlo in un Integer.

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

AFAIK puoi semplicemente usare

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

anche se è NULL.

Solo un aggiornamento con Java Generics.

È possibile creare un metodo di utilità per recuperare un valore facoltativo di qualsiasi tipo Java da un determinato ResultSet, precedentemente trasmesso.

Sfortunatamente, getObject (columnName, Class) non restituisce null, ma il valore predefinito per un determinato tipo di Java, quindi sono necessarie 2 chiamate

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

In questo esempio, il codice potrebbe essere simile al seguente:

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

Felice di ricevere feedback

È possibile chiamare questo metodo utilizzando il resultSet e il nome della colonna con tipo Numero. Restituirà il valore Intero o null. Non verranno restituiti zeri per valore vuoto nel database

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 puoi fare questo:

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

In tal caso, si assicura che nVal sarà null (e non zero) se il valore SQL è NULL

Per comodità, è possibile creare una classe wrapper attorno a ResultSet che restituisce valori null quando ResultSetnormalmente non lo sarebbe.

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

    // ...

}

Un altro bel modo di controllare, se si ha il controllo di SQL, è quello di aggiungere un valore predefinito nella query stessa per la colonna int. Quindi controlla solo quel valore.

ad es. per un database Oracle, utilizzare NVL

SELECT NVL(ID_PARENT, -999) FROM TABLE_NAME;

quindi controlla

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

Naturalmente anche questo presuppone che esista un valore che normalmente non si trova nella colonna.