Java ResultSet cómo verificar si hay resultados

Resultset no tiene ningún método para hasNext. Quiero verificar si el resultSet tiene algún valor

es esta la forma correcta

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

Eso es correcto, inicialmente el ResultSetcursor del 's apunta antes de la primera fila, si la primera llamada a next()retorna, falseentonces no había datos en el ResultSet.

Si usa este método, es posible que deba llamar beforeFirst()inmediatamente después para restablecerlo, ya que ahora se ha posicionado más allá de la primera fila.

Sin embargo, debe tenerse en cuenta que la respuesta de Seifer a continuación es una solución más elegante para esta pregunta.

Suponiendo que está trabajando con un recién devuelto ResultSetcuyo cursor apunta antes de la primera fila, una forma más fácil de verificar esto es simplemente llamar isBeforeFirst(). Esto evita tener que retroceder si los datos se van a leer.

Como se explica en la documentación , esto devuelve falso si el cursor no está antes del primer registro o si no hay filas en el ResultSet .

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

siempre puedes hacer lo siguiente por adelantado, y solo hacer una comprobación de bucle posterior

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

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

Usualmente harías algo como esto:

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

Si desea informar un conjunto vacío, agregue una variable que cuente los elementos leídos. Si solo necesita leer un solo elemento, entonces su código es adecuado.

Para estar totalmente seguro de que el conjunto de resultados está vacío o no, independientemente de la posición del cursor, haría algo como esto:

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

Esta función devolverá verdadero si ResultSet está vacío, falso si no, o arrojará una SQLException si ese ResultSet está cerrado / sin inicializar.

Es mejor usar ResultSet.next () junto con la sintaxis do {...} while () para esto.

La llamada "comprobar si hay resultados" ResultSet.next () mueve el cursor a la primera fila, así que use la sintaxis do {...} while () para procesar esa fila mientras continúa procesando las filas restantes devueltas por el bucle.

De esta manera, puede verificar los resultados, mientras que al mismo tiempo también procesa los resultados devueltos.

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

Según la respuesta más viable, la sugerencia es usar "isBeforeFirst ()". Esa no es la mejor solución si no tiene un "tipo de solo reenvío" .

Hay un método llamado " .first () ". Es menos exagerado obtener exactamente el mismo resultado. Verifica si hay algo en su "conjunto de resultados" y no avanza el cursor.

La documentación dice: "(...) falso si no hay filas en el conjunto de resultados ".

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

También puede simplemente llamar a isBeforeFirst () para probar si hay filas devueltas sin avanzar el cursor, luego proceder normalmente. - SnakeDoc Sep 2 '14 a las 19:00

Sin embargo, hay una diferencia entre "isBeforeFirst ()" y "first ()". Primero genera una excepción si se realiza en un conjunto de resultados del tipo "solo reenviar".

Compare las dos secciones de lanzamiento: 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 ()

De acuerdo, básicamente esto significa que debe usar "isBeforeFirst" siempre que tenga un tipo "solo reenvío". De lo contrario, es menos exagerado usar "first ()".

Eso funcionaría si desea ver si hay filas en el conjunto de resultados sí.

Tenga en cuenta que next()siempre se mueve a la siguiente fila, por lo que si planea leer el conjunto de resultados, debe tenerlo en cuenta.

El uso habitual con ResultSet (cuando simplemente se lee) es:

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

Lo que obviamente no funcionará correctamente si ya invocaste next()una vez para verificar si el conjunto de resultados estaba vacío, así que ten cuidado con eso. Aunque existen métodos para "realizar copias de seguridad", no son compatibles con todos los tipos de conjuntos de resultados.

Esta es una pieza práctica y fácil de leer, creo.

        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() también devuelve falso para el conjunto de resultados vacío, pero como el cursor está antes de la primera fila, este método parece más claro.

if(resultSet.first) {

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

Porque si ResultSet no tiene raw, resultSet.firstdevuelve false.

Lo mejor que puede hacer es verificar la primera fila para que cuando tenga la intención de obtener los datos pueda evitar el error de omitir una fila. Algo así como: if (! ResultSet.first ()) {System.out.println ("sin datos"); }

Al usar resultSet.next () puede obtener fácilmente el resultado, ya sea que resultSet contenga algún valor o no

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

He estado intentando establecer la fila actual en el primer índice (que trata con las claves principales). Yo sugeriría

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

Cuando se llena ResultSet, apunta antes de la primera fila. Al establecerlo en la primera fila (indicado por rs.absolute(1)), devolverá verdadero indicando que se colocó con éxito en la fila 1, o falso si la fila no existe. Podemos extrapolar esto a

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

que establece la fila actual en la posición i y fallará si la fila no existe. Este es solo un método alternativo para

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

Creé el siguiente método para verificar si un ResultSet está vacío.

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

Es muy importante tener las siguientes consideraciones:

El objeto CallableStatement debe configurarse para permitir que el objeto ResultSet vaya al final y vuelva al principio.

TYPE_SCROLL_SENSITIVE : el objeto ResultSet puede desplazarse al final y volver al principio. Además puede atrapar los últimos cambios.

CONCUR_READ_ONLY : podemos leer los datos del objeto ResultSet, pero no podemos actualizarlos.

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

Creo que la forma más fácil de verificar el conjunto de resultados es a través de CollectionUtils en el paquete org.apache.commons.collections.CollectionUtils

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

Esto verificará la condición del conjunto de resultados nulo y vacío.

Para obtener más información detallada, puede consultar el siguiente documento. ColecciónUtils

¿Por qué no usar 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

Para mí, marcar "if (rs.getRow ()! = 0)" parece funcionar bien.

puedes hacer algo como esto

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
}

Es mejor volver a ejecutar la consulta porque cuando llamamos a la if(rs.next()){....}primera fila de ResultSet se ejecutará y después de esto while(rs.next()){....}, obtendremos el resultado de la siguiente línea. Así que creo que la re-ejecución de la consulta dentro ifes la mejor opción.

Inicialmente, el objeto del conjunto de resultados (rs) apunta al BFR (antes del primer registro). Una vez que usamos rs.next (), el cursor apunta al primer registro y el rs tiene "verdadero". Usando el bucle while puede imprimir todos los registros de la tabla. Después de recuperar todos los registros, el cursor se mueve a ALR (después del último registro) y se establecerá en nulo. Consideremos que hay 2 registros en la tabla.

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

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

En resumen, también podemos escribir la condición como while (rs.next ()).