Risultati Java Impostare come verificare se ci sono risultati

resultset non ha alcun metodo per hasNext. Voglio verificare se il resultSet ha qualche valore

è questo il modo corretto

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

È corretto, inizialmente il ResultSetcursore punta prima della prima riga, se la prima chiamata next()ritorna, falseallora non c'erano dati nel file ResultSet.

Se si utilizza questo metodo, potrebbe essere necessario chiamare beforeFirst() subito dopo per ripristinarlo, poiché ora si è posizionato oltre la prima riga.

Va notato tuttavia che la risposta di Seifer di seguito è una soluzione più elegante a questa domanda.

Supponendo che tu stia lavorando con un nuovo restituito il ResultSetcui cursore punta prima della prima riga, un modo più semplice per verificare questo è semplicemente chiamareisBeforeFirst() . Questo evita di dover tornare indietro se i dati devono essere letti.

Come spiegato nella documentazione , questo restituisce false se il cursore non si trova prima del primo record o se non ci sono righe nel ResultSet .

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

potresti sempre fare il prossimo passo avanti e fare solo un controllo post loop

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

    do {
     //statement(s)
    } while (resultSet.next());
}

Di solito faresti qualcosa del genere:

while ( resultSet.next() ) { 
   // Read the next item
   resultSet.getString("columnName");
}

Se si desidera segnalare un set vuoto, aggiungere una variabile contando gli elementi letti. Se hai solo bisogno di leggere un singolo elemento, il tuo codice è adeguato.

Per essere totalmente sicuro piuttosto che il set di risultati sia vuoto o no indipendentemente dalla posizione del cursore, farei qualcosa del genere:

public static boolean isMyResultSetEmpty(ResultSet rs) throws SQLException {
    return (!rs.isBeforeFirst() && rs.getRow() == 0);
}

Questa funzione restituirà true se ResultSet è vuoto, false in caso contrario o genera un'eccezione SQLE se tale ResultSet è chiuso / non inizializzato.

È meglio usare ResultSet.next () insieme alla sintassi do {...} while () per questo.

La chiamata "controlla eventuali risultati" ResultSet.next () sposta il cursore sulla prima riga, quindi usa la sintassi do {...} while () per elaborare quella riga mentre continua a elaborare le restanti righe restituite dal ciclo.

In questo modo è possibile verificare la presenza di risultati, mentre allo stesso tempo elaborare anche i risultati restituiti.

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

Secondo la risposta più valida, il suggerimento è di usare "isBeforeFirst ()". Questa non è la soluzione migliore se non si dispone di un "tipo solo forward" .

C'è un metodo chiamato " .first () ". È meno eccessivo ottenere lo stesso risultato esatto. Controlla se c'è qualcosa nel tuo "gruppo di risultati" e non avanzi il cursore.

La documentazione afferma: "(...) false se non ci sono righe nel set di risultati ".

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

Puoi anche chiamare isBeforeFirst () per verificare se ci sono righe restituite senza far avanzare il cursore, quindi procedere normalmente. - SnakeDoc 2 settembre 14 alle 19:00

Tuttavia, c'è una differenza tra "isBeforeFirst ()" e "first ()". Innanzitutto genera un'eccezione se eseguita su un gruppo di risultati dal tipo "solo inoltro".

Confronta le due sezioni di lancio: 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 ()

Ok, in pratica questo significa che dovresti usare "isBeforeFirst" fintanto che hai un tipo "forward only". Altrimenti è meno eccessivo usare "first ()".

Funzionerebbe se si desidera vedere se ci sono righe nel set di risultati yes.

Nota che next()passa sempre alla riga successiva, quindi se stai pianificando di leggere il set di risultati devi tenerne conto.

L'utilizzo abituale con ResultSet (quando si legge semplicemente) è:

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

Che ovviamente non funzionerà correttamente se hai next()già invocato una volta per verificare se il set di risultati era vuoto, quindi fai attenzione. Sebbene esistano metodi per il "backup", non sono supportati per tutti i tipi di set di risultati.

Questo è un pezzo pratico e facile da leggere, credo.

        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() restituisce anche false per set di risultati vuoto ma poiché il cursore si trova comunque prima della prima riga, questo metodo sembra più chiaro.

if(resultSet.first) {

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

Perché se ResultSet non ha raw, resultSet.firstrestituisce false.

La cosa migliore da fare è controllare la prima riga in modo che quando si intende ottenere i dati sia possibile evitare l'errore di saltare una riga. Qualcosa come: if (! ResultSet.first ()) {System.out.println ("nessun dato"); }

Usando resultSet.next () è possibile ottenere facilmente il risultato, indipendentemente dal fatto che resultSet contenga un valore

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

Ho tentato di impostare la riga corrente sul primo indice (gestendo le chiavi primarie). io suggerirei

if(rs.absolute(1)){
    System.out.println("We have data");
} else {
    System.out.println("No data");
}

Quando il ResultSet viene popolato, punta prima della prima riga. Quando lo si imposta sulla prima riga (indicato da rs.absolute(1)), verrà restituito true, a indicare che è stato posizionato correttamente nella riga 1 o false se la riga non esiste. Possiamo estrapolarlo a

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

che imposta la riga corrente in posizione i e fallirà se la riga non esiste. Questo è solo un metodo alternativo a

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

Ho creato il seguente metodo per verificare se un ResultSet è vuoto.

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

È molto importante avere le seguenti considerazioni:

L' oggetto CallableStatement deve essere impostato per lasciare andare l'oggetto ResultSet alla fine e tornare all'inizio.

TYPE_SCROLL_SENSITIVE : l'oggetto ResultSet può spostarsi alla fine e tornare all'inizio. Inoltre, è possibile rilevare le ultime modifiche.

CONCUR_READ_ONLY : possiamo leggere i dati dell'oggetto ResultSet, ma non possiamo aggiornarli.

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

Penso che il modo più semplice per controllare il set di risultati sia tramite CollectionUtils nel pacchetto org.apache.commons.collections.CollectionUtils

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

Ciò verificherà la condizione del set di risultati null e vuota.

Per ulteriori informazioni di dettaglio è possibile fare riferimento al seguente documento. CollectionUtils

Perché non usare 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

Per me controllare "if (rs.getRow ()! = 0)" sembra funzionare bene.

puoi fare qualcosa del genere

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
}

È meglio rieseguire la query perché quando chiamiamo la if(rs.next()){....}prima riga di ResultSet verrà eseguita e dopo che all'interno while(rs.next()){....}otterremo il risultato dalla riga successiva. Quindi penso che la riesecuzione della query all'interno ifsia l'opzione migliore.

Inizialmente, l'oggetto set di risultati (rs) punta al BFR (prima del primo record). Quando usiamo rs.next (), il cursore punta sul primo record e rs mantiene "true". Utilizzando il ciclo while è possibile stampare tutti i record della tabella. Dopo aver recuperato tutti i record, il cursore si sposta su ALR (Dopo l'ultimo record) e verrà impostato su null. Consideriamo che ci sono 2 record nella tabella.

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

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

In breve, possiamo anche scrivere la condizione as while (rs.next ()).