Recherche d'une valeur int nulle à partir d'un ensemble de résultats Java

En Java, j'essaie de tester une valeur nulle, à partir d'un ResultSet, où la colonne est convertie en un type int primitif .

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

D'après le fragment de code ci-dessus, existe-t-il une meilleure façon de le faire, et je suppose que le deuxième test wasNull () est redondant?

Renseignez-nous et merci

La valeur par défaut ResultSet.getIntlorsque la valeur du champ NULLest de retourner 0, qui est également la valeur par défaut de votre iValdéclaration. Dans ce cas, votre test est complètement redondant.

Si vous voulez réellement faire quelque chose de différent si la valeur du champ est NULL, je suggère:

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

(Modifié sous les commentaires @martin ci-dessous; le code OP tel qu'il est écrit ne se compilera pas car il iValn'est pas initialisé)

Une autre solution:

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

Je pense que c'est redondant. rs.getObject("ID_PARENT")doit renvoyer un Integerobjet ou null, si la valeur de la colonne était réellement NULL. Il devrait donc même être possible de faire quelque chose comme:

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

Vérifiez simplement si le champ nullutilise ou non ResultSet#getObject(). Remplacez -1par la valeur de casse nulle souhaitée.

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

Ou, si vous pouvez garantir que vous utilisez le bon type de colonne de base de données de manière à ce ResultSet#getObject()qu'il renvoie vraiment un Integer(et donc pas Long, Shortou Byte), vous pouvez également le transtyper en un Integer.

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

AFAIK, vous pouvez simplement utiliser

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

même si c'est NULL.

Juste une mise à jour avec Java Generics.

Vous pouvez créer une méthode utilitaire pour récupérer une valeur facultative de tout type Java à partir d'un ResultSet donné, préalablement casté.

Malheureusement, getObject (columnName, Class) ne renvoie pas null, mais la valeur par défaut pour le type Java donné, donc 2 appels sont requis

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

Dans cet exemple, votre code pourrait ressembler à ci-dessous:

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

Heureux d'avoir des commentaires

Vous pouvez appeler cette méthode à l'aide de resultSet et du nom de colonne de type Number. Il retournera soit la valeur entière, soit null. Aucun zéro ne sera retourné pour la valeur vide dans la base de données

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

Avec java 8, vous pouvez faire ceci:

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

Dans ce cas, vous vous assurez que le nVal sera nul (et non nul) si la valeur SQL est NULL

Pour plus de commodité, vous pouvez créer une classe wrapper autour de ResultSet qui renvoie des valeurs nulles alors que ResultSetce n'est généralement pas le cas.

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

    // ...

}

Une autre bonne façon de vérifier, si vous avez le contrôle du SQL, est d'ajouter une valeur par défaut dans la requête elle-même pour votre colonne int. Vérifiez ensuite cette valeur.

par exemple pour une base de données Oracle, utilisez NVL

SELECT NVL(ID_PARENT, -999) FROM TABLE_NAME;

puis vérifier

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

Bien sûr, cela est également sous l'hypothèse qu'il existe une valeur qui ne serait normalement pas trouvée dans la colonne.