Obtenir le Nombre de Lignes retournées par ResultSet en Java

J'ai utilisé un ResultSet qui renvoie certain nombre de lignes. Mon code est quelque chose comme ceci:

ResultSet res = getData();
if(!res.next())
{
    System.out.println("No Data Found");
}
while(res.next())
{
    //code to display the data in the table.
}

Est il une méthode pour vérifier le nombre de lignes retournées par la ResultSet? Ou dois-je écrire mon propre?

Doublon de: stackoverflow.com/questions/7545820/...

InformationsquelleAutor Kiran | 2011-11-28

java resultset

53

Vous pouvez utiliser un do ... while boucle au lieu d'un while boucle, de sorte que rs.next() est appelé après que la boucle est exécutée, comme ceci:
```
if (!rs.next()) {                            //if rs.next() returns false
                                             //then there are no rows.
    System.out.println("No records found");

}
else {
    do {
        //Get data from the current row and use it
    } while (rs.next());
}
```
Ou compter les lignes de vous-même que vous les obtenir:
```
int count = 0;

while (rs.next()) {
    ++count;
    //Get data from the current row and use it
}

if (count == 0) {
    System.out.println("No records found");
}
```
- je suis à l'aide de code ci-dessus mais et afficher des enregistrements, mais il perd le premier enregistrement
- index de ligne commence à partir de 1 dans le jeu de résultat
- Pas de ligne d'index est utilisé dans les exemples ci-dessus de sorte qu'il n'a pas d'importance si l'index de ligne démarre à 1 ou quoi que ce soit d'autre.
- Peut-être que @KaranRajput est de l'utiliser. Je ne sais pas comment perdre du premier enregistrement, de sorte que c'était une astuce dans le cas où il est à l'aide de matières index.
InformationsquelleAutor Jesper
68

Tout d'abord, vous devez créer Statement qui peut être déplacer le curseur par la commande:
```
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
```
Puis récupérer le ResultSet comme ci-dessous:
```
ResultSet rs = stmt.executeQuery(...);
```
Déplacer le curseur sur la dernière ligne et obtenir:
```
if (rs.last()) {
    int rows = rs.getRow();
    //Move to beginning
    rs.beforeFirst();
    ...
}
```
Puis lignes variable contient le nombre de lignes retournées par sql
- attention: en cas de ojdbc, si vous appelez rs.dernier le jeu de résultats est répété et mis en cache. donc, cela peut conduire à des imprévus de la consommation de mémoire
InformationsquelleAutor Tu Tran

Un simple getRowCount méthode peut ressembler à ceci :

private int getRowCount(ResultSet resultSet) {
    if (resultSet == null) {
        return 0;
    }
    try {
        resultSet.last();
        return resultSet.getRow();
    } catch (SQLException exp) {
        exp.printStackTrace();
    } finally {
        try {
            resultSet.beforeFirst();
        } catch (SQLException exp) {
            exp.printStackTrace();
        }
    }
    return 0;
}

Juste être conscient que cette méthode aura besoin d'un défilement sensible au jeu de résultats, lors de la création de la connexion, vous devez spécifier l'option de défilement. Par défaut est à l'AVANT et à l'aide de cette méthode va vous jeter exception.

Le jeu de résultats.last(); ligne renvoie la valeur booléenne, veuillez indiquer si l'énoncé.

InformationsquelleAutor mprabhat

Une autre façon de différencier entre 0 lignes ou des lignes à partir d'un jeu de résultats:

ResultSet res = getData();

if(!res.isBeforeFirst()){          //res.isBeforeFirst() is true if the cursor
                                   //is before the first row.  If res contains
                                   //no rows, rs.isBeforeFirst() is false.

    System.out.println("0 rows");
}
else{
    while(res.next()){
        //code to display the rows in the table.
    }
}

Si vous devez connaître le nombre de lignes étant donné un jeu de résultats, voici une méthode pour l'obtenir:

public int getRows(ResultSet res){
    int totalRows = 0;
    try {
        res.last();
        totalRows = res.getRow();
        res.beforeFirst();
    } 
    catch(Exception ex)  {
        return 0;
    }
    return totalRows ;    
}

InformationsquelleAutor Fathah Rehman P

6

res.next() méthode prendra le pointeur à la ligne suivante. et dans votre code, vous utilisez deux fois, d'abord pour la condition if (curseur se déplace à la première ligne), ensuite, pour la condition du while (curseur se déplace vers la deuxième rangée).

Ainsi, lorsque vous accédez à vos résultats, il commence à partir de la deuxième ligne. Donc, montre une ligne de moins en moins de résultats.

vous pouvez essayer ceci :
```
if(!res.next()){ 
    System.out.println("No Data Found");  
}
else{
    do{
       //your code
    } 
    while(res.next());
}
```
InformationsquelleAutor gprathour

On pouvait compter avec sql et récupérer la réponse du jeu de résultats comme suit:

Statment stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 
                                     ResultSet.CONCUR_READ_ONLY);
ResultSet ct = stmt.executeQuery("SELECT COUNT(*) FROM [table_name]");
if(ct.next()){
   td.setTotalNumRows(ct.getInt(1));
}

Ici, je suis de tout compter, mais vous pouvez facilement modifier le SQL à compter basée sur un critère.

nice et la solution la plus simple !!

InformationsquelleAutor Emmanuel John

        rs.last();
        int rows = rs.getRow();
        rs.beforeFirst();

InformationsquelleAutor Nael Abd eljawad

0

Vous pouvez charger le jeu de résultats dans un TableModel, puis créer un JTable qui utilise cette TableModel, puis utilisez le tableau.méthode getRowCount (). Si vous allez à l'affichage du résultat de la requête, vous devez le faire de toute façon.
```
ResultSet resultSet;
resultSet = doQuery(something, somethingelse);
KiransTableModel myTableModel = new KiransTableModel(resultSet);
JTable table = new JTable(KiransTableModel);
int rowCount;
rowCount = table.getRowCount;
```
InformationsquelleAutor bsdarby
0
```
Statement st = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
ResultSet rs=st.executeQuery("select * from emp where deptno=31");
rs.last();
System.out.println("NoOfRows: "+rs.getRow());
```
première ligne de code dit que nous pouvons aller n'importe où dans le jeu de résultats( que ce soit à la première ligne ou la dernière ligne, ou avant la première ligne sans avoir besoin de parcourir ligne par ligne en commençant à partir de la première rangée, qui est le temps de prendre).deuxième ligne de code récupère les documents correspondant à la requête ici, je suis en supposant (25 dossiers), de la troisième ligne de code déplace le curseur vers la dernière ligne et la dernière ligne du code de la ligne actuelle, qui est de 25 dans mon cas. si il n'y a pas d'enregistrements, rs.dernière renvoie 0 et getrow déplace le curseur avant la première ligne donc retourner une valeur négative indique l'absence d'enregistrements en db
- pouvez-vous expliquer avec une explication de comment cela peut aider ?
- première ligne de code dit que nous pouvons aller n'importe où dans le jeu de résultats( que ce soit à la première ligne ou la dernière ligne, ou avant la première ligne sans avoir besoin de parcourir ligne par ligne en commençant à partir de la première rangée, qui est le temps de prendre).deuxième ligne de code récupère les documents correspondant à la requête ici, je suis en supposant (25 dossiers), de la troisième ligne de code déplace le curseur vers la dernière ligne et la dernière ligne du code de la ligne actuelle, qui est de 25 dans mon cas. si il n'y a pas d'enregistrements, rs.dernière renvoie 0 et getrow déplace le curseur avant la première ligne donc retourner une valeur négative indique l'absence d'enregistrements dans la base de données.
InformationsquelleAutor pradeep kumar

ce ma solution

 ResultSet rs=Statement.executeQuery("query");

    int rowCount=0;


    if (!rs.isBeforeFirst()) 
      {

           System.out.println("No DATA" );
        } else {
            while (rs.next()) {
                rowCount++; 
            System.out.println("data1,data2,data3...etc..");
            }
            System.out.println(rowCount);
            rowCount=0;
            rs.close();
            Statement.close();
      }

InformationsquelleAutor Yusuf Kalsen

-1

Vous pouvez utiliser res.previous() comme suit:

ResulerSet res = getDate();
if(!res.next()) {
    System.out.println("No Data Found.");
} else {
    res.previous();
    while(res.next()) {
      //code to display the data in the table.
    }
}

InformationsquelleAutor Yatin

Vous devez vous connecter pour publier un commentaire.