Java ResultSet comment vérifier s'il y a des résultats
Resultset n'a pas de méthode pour hasNext. Je veux vérifier si le resultSet a une valeur
est-ce la bonne façon
if (!resultSet.next() ) {
System.out.println("no data");
}
C'est exact. Initialement, le curseur de ResultSet pointe avant la première ligne. Si le premier appel à next() renvoie false, il n'y avait aucune donnée dans ResultSet.
Si vous utilisez cette méthode, vous devrez peut-être appeler beforeFirst() immédiatement après pour la réinitialiser, car elle s'est positionnée au-delà de la première ligne.
Il convient toutefois de noter que réponse de Seifer ci-dessous est une solution plus élégante à cette question.
En supposant que vous travailliez avec un ResultSet récemment renvoyé dont le curseur pointe avant la première ligne, une méthode plus simple pour vérifier cela consiste simplement à appeler isBeforeFirst(). Cela évite d'avoir à revenir en arrière si les données doivent être lues.
Comme expliqué dans la documentation , cela retourne la valeur false si le curseur ne se trouve pas avant le premier enregistrement ou si le jeu de résultats ne contient aucune ligne .
if (!resultSet.isBeforeFirst() ) {
System.out.println("No data");
}
vous pouvez toujours faire la prochaine étape, et juste faire une vérification post boucle
if (!resultSet.next() ) {
System.out.println("no data");
} else {
do {
//statement(s)
} while (resultSet.next());
}
Vous feriez habituellement quelque chose comme ça:
while ( resultSet.next() ) {
// Read the next item
resultSet.getString("columnName");
}
Si vous souhaitez signaler un ensemble vide, ajoutez une variable comptant les éléments lus. Si vous n'avez besoin que de lire un seul élément, votre code est adéquat.
Pour être tout à fait sûr que le résultat est vide ou non, peu importe la position du curseur, je ferais quelque chose comme ceci:
public static boolean isMyResultSetEmpty(ResultSet rs) throws SQLException {
return (!rs.isBeforeFirst() && rs.getRow() == 0);
}
Cette fonction retournera true si ResultSet est vide, false sinon, ou lève une exception SQLException si ce ResultSet est fermé/non initialisé.
Il est préférable d’utiliser ResultSet.next () avec la syntaxe do {...} while () pour cela.
ResultSet.next () appelle le "contrôle des résultats" pour déplacer le curseur sur la première ligne. Utilisez donc la syntaxe do {...} while () pour traiter cette ligne tout en continuant de traiter les lignes restantes renvoyées par la boucle.
De cette façon, vous pouvez vérifier tous les résultats, tout en traitant également les résultats renvoyés.
if(resultSet.next()) { // Checks for any results and moves cursor to first row,
do { // Use 'do...while' to process the first row, while continuing to process remaining rows
} while (resultSet.next());
}
Selon la réponse la plus viable, il est suggéré d'utiliser "isBeforeFirst ()". Ce n'est pas la meilleure solution si vous ne disposez pas d'un "type de transmission uniquement" .
Il existe une méthode appelée " . First () ". Il est moins exagéré d'obtenir le même résultat. Vous vérifiez s'il y a quelque chose dans votre "résultats" et ne faites pas avancer votre curseur.
La documentation indique: "(...) false s'il n'y a aucune ligne dans le jeu de résultats ".
if(rs.first()){
//do stuff
}
Vous pouvez également simplement appeler isBeforeFirst () pour vérifier si des lignes sont renvoyées sans avancer le curseur, puis procédez normalement. - SnakeDoc 2 septembre 14 à 19:00
Cependant, il existe une différence entre "isBeforeFirst ()" et "first ()". Génère d’abord une exception si elle est effectuée sur un jeu de résultats à partir du type "transmettre uniquement".
Comparez les deux sections de projection: http://docs.Oracle.com/javase/7/docs/api/Java/sql/ResultSet.html#isBeforeFirst ()http: // docs.Oracle.com/javase/7/docs/api/Java/sql/ResultSet.html#first()
En gros, cela signifie que vous devez utiliser "isBeforeFirst" tant que vous avez le type "transférer uniquement". Sinon, il est moins excessif d'utiliser "first ()".
C’est une pièce pratique et facile à lire, je crois.
if (res.next()) {
do {
// successfully in. do the right things.
} while (res.next());
} else {
// no results back. warn the user.
}
Cela fonctionnerait si vous voulez voir s'il y a des lignes dans le jeu de résultats, oui.
Notez que next() passe toujours à la ligne suivante. Par conséquent, si vous envisagez de lire des résultats à partir du jeu de résultats, vous devez en tenir compte.
L’usage habituel avec ResultSet (lors d’une lecture simple) est:
while (resultSet.next())
{
... read from the row here ...
}
Ce qui ne fonctionnera évidemment pas correctement si vous appelez déjà next() une fois pour vérifier si le jeu de résultats est vide, alors faites attention à cela. Bien qu'il existe des méthodes de "sauvegarde", elles ne sont pas prises en charge pour tous les types de jeux de résultats.
if (!resultSet.isAfterLast() ) {
System.out.println("No data");
}
isAfterLast() renvoie également la valeur false pour le jeu de résultats vide, mais comme le curseur se trouve de toute façon avant la première ligne, cette méthode semble plus claire.
La meilleure chose à faire est de vérifier la première ligne de sorte que lorsque vous avez l’intention d’obtenir les données, vous évitiez l’erreur de sauter une ligne. Quelque chose comme: if (! ResultSet.first ()) {System.out.println ("pas de données"); }
if(resultSet.first) {
} else {
system.out.println("No raw or resultSet is empty");
}
Parce que si ResultSet n'a pas de raw, alors resultSet.first renvoie false.
J'ai créé la méthode suivante pour vérifier si un ResultSet est vide.
public static boolean resultSetIsEmpty(ResultSet rs){
try {
// We point the last row
rs.last();
int rsRows=rs.getRow(); // get last row number
if (rsRows == 0) {
return true;
}
// It is necessary to back to top the pointer, so we can see all rows in our ResultSet object.
rs.beforeFirst();
return false;
}catch(SQLException ex){
return true;
}
}
Il est très important d'avoir les considérations suivantes:
CallableStatement l'objet doit être configuré pour laisser l'objet ResultSet aller à la fin et revenir en haut.
TYPE_SCROLL_SENSITIVE: L'objet ResultSet peut être déplacé à la fin et revenir en haut. En outre peut attraper les derniers changements.
CONCUR_READ_ONLY: Nous pouvons lire les données d'objet ResultSet, mais ne pouvons pas les mettre à jour.
CallableStatement proc = dbconex.prepareCall(select, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
Avec resultSet.next (), vous pouvez facilement obtenir le résultat, que resultSet contienne ou non une valeur.
ResultSet resultSet = preparedStatement.executeQuery();
if(resultSet.next())
//resultSet contain some values
else
// empty resultSet
ResultSet result = stmt.executeQuery(sqlQuery);
if (!result.next())
status = "ERROR";
else
status = "SUCCESS";
ResultSet rs = rs.executeQuery();
if(rs.next())
{
rs = rs.executeQuery();
while(rs.next())
{
//do code part
}
}
else
{
//else if no result set
}
Il est préférable d'exécuter à nouveau la requête car lorsque nous appellerons if(rs.next()){....}, la première ligne de ResultSet sera exécutée et, après celle-ci, dans while(rs.next()){....}, nous obtiendrons le résultat de la ligne suivante. Donc, je pense que la meilleure exécution est la ré-exécution de la requête à l'intérieur de if.
J'ai essayé de définir la ligne actuelle sur le premier index (traitant des clés primaires). je voudrais suggerer
if(rs.absolute(1)){
System.out.println("We have data");
} else {
System.out.println("No data");
}
Lorsque le ResultSet est rempli, il pointe avant la première ligne. Lorsque vous le définissez sur la première ligne (indiquée par rs.absolute(1)), il renvoie la valeur true, indiquant qu'il a bien été placé sur la ligne 1, ou false si la ligne n'existe pas. Nous pouvons extrapoler cela à
for(int i=1; rs.absolute(i); i++){
//Code
}
qui définit la ligne actuelle sur la position i et échouera si la ligne n’existe pas. Ceci est juste une méthode alternative à
while(rs.next()){
//Code
}
Pourquoi ne pas utiliser rs.getRow ()?
int getRow()
throws SQLException
Retrieves the current row number. The first row is number 1, the second number 2, and so on.
Note:Support for the getRow method is optional for ResultSets with a result set type of TYPE_FORWARD_ONLY
Returns:
the current row number; 0 if there is no current row
Throws:
SQLException - if a database access error occurs or this method is called on a closed result set
SQLFeatureNotSupportedException - if the JDBC driver does not support this method
Since:
1.2
Pour moi, vérifiez "if (rs.getRow ()! = 0)" semble bien fonctionner.
tu peux faire quelque chose comme ça
boolean found = false;
while ( resultSet.next() )
{
found = true;
resultSet.getString("column_name");
}
if (!found)
System.out.println("No Data");
Je pense que le moyen le plus simple de vérifier les résultats obtenus consiste à CollectionUtils sous package org.Apache.commons.collections.CollectionUtils
if(CollectionUtils.isNotEmpty(resultList)){
/**
* do some stuff
*/
}
Cela vérifiera la valeur null ainsi que la condition de jeu de résultats vide.
Pour plus d'informations, vous pouvez vous reporter à la documentation suivante. CollectionUtils