Java ResultSet comment vérifier s'il y a des résultats

L'ensemble de résultats n'a pas de méthode pour hasNext. Je veux vérifier si le resultSet a une valeur

C'est la bonne route

if (!resultSet.next() ) {
    System.out.println("no data");
} 

C'est vrai, au départ, le ResultSetcurseur pointe vers la première ligne, si le premier appel à next()renvoie falsealors il n'y avait pas de données dans le 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 maintenant.

Il convient toutefois de noter que la réponse de Seifer ci-dessous est une solution plus élégante à cette question.

En supposant que vous travaillez avec un nouveau retour ResultSetdont le curseur pointe avant la première ligne, un moyen plus simple de vérifier ceci 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 renvoie false si le curseur n'est pas avant le premier enregistrement ou s'il n'y a pas de lignes dans le ResultSet .

if (!resultSet.isBeforeFirst() ) {    
    System.out.println("No data"); 
} 

vous pouvez toujours faire le prochain à l'avant, 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 généralement quelque chose comme ceci:

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 de lire qu'un seul élément, votre code est suffisant.

Pour être totalement sûr que le jeu de résultats est vide ou non, quelle que soit 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 dans le cas contraire ou lèvera 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.

L'appel "vérifier les résultats" appelle ResultSet.next () déplace le curseur sur la première ligne, utilisez donc la syntaxe do {...} while () pour traiter cette ligne tout en continuant à traiter les lignes restantes renvoyées par la boucle.

De cette façon, vous pouvez vérifier 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, la suggestion est d'utiliser "isBeforeFirst ()". Ce n'est pas la meilleure solution si vous n'avez pas de "type de transfert uniquement" .

Il existe une méthode appelée " .first () ". Il est moins exagéré d'obtenir exactement le même résultat. Vous vérifiez s'il y a quelque chose dans votre "jeu de résultats" et vous ne faites pas avancer votre curseur.

La documentation indique: "(...) false s'il n'y a pas de lignes dans le jeu de résultats ".

if(rs.first()){
    //do stuff      
}

Vous pouvez également simplement appeler isBeforeFirst () pour tester s'il y a des lignes retournées sans faire avancer le curseur, puis procédez normalement. - SnakeDoc du 2 septembre 2014 à 19h00

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 de type "avant 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 ()

D'accord, cela signifie que vous devez utiliser "isBeforeFirst" tant que vous avez un type "avant uniquement". Sinon, il est moins exagéré d'utiliser "first ()".

Cela fonctionnerait si vous voulez voir s'il y a des lignes dans le jeu de résultats oui.

Notez que next()vous passez toujours à la ligne suivante, donc si vous prévoyez de faire une lecture de l'ensemble de résultats, vous devez en tenir compte.

L'utilisation habituelle avec ResultSet (lors de la simple lecture) est:

while (resultSet.next())
{
   ... read from the row here ...
}

Ce qui évidemment ne fonctionnera pas correctement si vous avez next()déjà invoqué une fois pour vérifier si le jeu de résultats était 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 d'ensembles de résultats.

Je pense que c'est un article pratique et facile à lire.

        if (res.next()) {
            do {

                // successfully in. do the right things.

            } while (res.next());
        } else {
           // no results back. warn the user.
        }

if (!resultSet.isAfterLast() ) {    
System.out.println("No data"); 
} 

isAfterLast() renvoie également false pour un jeu de résultats vide mais puisque le curseur est de toute façon avant la première ligne, cette méthode semble plus claire.

if(resultSet.first) {

} else { 
    system.out.println("No raw or resultSet is empty");
}

Parce que si ResultSet n'a pas de brut, resultSet.firstrenvoie false.

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 puissiez éviter l'erreur de sauter une ligne. Quelque chose comme: if (! ResultSet.first ()) {System.out.println ("no data"); }

En utilisant resultSet.next (), vous pouvez facilement obtenir le résultat, que resultSet contienne une valeur ou non

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

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 la définissez sur la première ligne (indiquée par rs.absolute(1)), elle renvoie true indiquant qu'elle a été correctement placée à la ligne 1, ou false si la ligne n'existe pas. Nous pouvons extrapoler ceci à

for(int i=1; rs.absolute(i); i++){
    //Code
}

ce qui définit la ligne actuelle à la position i et échouera si la ligne n'existe pas. Ceci est juste une méthode alternative à

while(rs.next()){
    //Code
}

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:

L' objet CallableStatement doit être défini pour laisser l'objet ResultSet aller à la fin et revenir en haut.

TYPE_SCROLL_SENSITIVE : l'objet ResultSet peut se déplacer à la fin et revenir en haut. En outre, vous pouvez attraper les derniers changements.

CONCUR_READ_ONLY : Nous pouvons lire les données de l'objet ResultSet, mais ne pouvons pas les mettre à jour.

CallableStatement proc = dbconex.prepareCall(select, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);

Je pense que le moyen le plus simple de vérifier l'ensemble de résultats est via CollectionUtils sous le package org.apache.commons.collections.CollectionUtils

if(CollectionUtils.isNotEmpty(resultList)){
  /**
  * do some stuff
  */
}

Cela vérifiera la condition de jeu de résultats vide et vide.

Pour plus d'informations, vous pouvez vous référer au document suivant. CollectionUtils

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, cochez "si (rs.getRow ()! = 0)" semble fonctionner très bien.

vous pouvez faire quelque chose comme ça

boolean found = false;

while ( resultSet.next() )
{
    found = true;
    resultSet.getString("column_name");
}

if (!found)
    System.out.println("No Data");

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 de réexécuter la requête car lorsque nous appelons la if(rs.next()){....}première ligne de ResultSet sera exécutée et après elle à l'intérieur, while(rs.next()){....}nous obtiendrons le résultat de la ligne suivante. Je pense donc que la réexécution de la requête à l'intérieur ifest la meilleure option.

Initialement, l'objet du jeu de résultats (rs) pointe vers le BFR (avant le premier enregistrement). Une fois que nous utilisons rs.next (), le curseur pointe vers le premier enregistrement et le rs est "vrai". En utilisant la boucle while, vous pouvez imprimer tous les enregistrements de la table. Une fois tous les enregistrements récupérés, le curseur se déplace sur ALR (après le dernier enregistrement) et il est défini sur null. Considérons qu'il y a 2 enregistrements dans le tableau.

if(rs.next()==false){
    // there are no records found
    }    

while (rs.next()==true){
    // print all the records of the table
    }

En bref, nous pouvons également écrire la condition sous la forme while (rs.next ()).