Come ottenere il conteggio delle righe utilizzando ResultSet in Java?

Sto provando a creare un metodo semplice che riceve un ResultSet come parametro e restituisce un int che contiene il conteggio delle righe del ResultSet. È un modo valido per fare questo o no così tanto?

int size = 0; try { while(rs.next()){ size++; } } catch(Exception ex) { System.out.println("------------------Tablerize.getRowCount-----------------"); System.out.println("Cannot get resultSet row count: " + ex); System.out.println("--------------------------------------------------------"); } 

Ho provato questo:

 int size = 0; try { resultSet.last(); size = resultSet.getRow(); resultSet.beforeFirst(); } catch(Exception ex) { return 0; } return size; 

Ma ho ricevuto un errore dicendo com.microsoft.sqlserver.jdbc.SQLServerException: The requested operation is not supported on forward only result sets.

Grazie in anticipo per i suggerimenti!

Se si ha accesso alla dichiarazione preparata che risulta in questo gruppo di risultati, è ansible utilizzare

 connection.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY); 

Questo prepara la tua dichiarazione in modo che tu possa riavvolgere il cursore. Questo è anche documentato in ResultSet Javadoc

In generale, tuttavia, i cursori di inoltro e riavvolgimento possono essere piuttosto inefficienti per i set di risultati di grandi dimensioni. Un’altra opzione in SQL Server consiste nel calcolare il numero totale di righe direttamente nell’istruzione SQL:

 SELECT my_table.*, count(*) over (partition by 1) total_rows FROM my_table WHERE ... 

il tuo codice di creazione di istruzioni SQL può essere come

 statement = connection.createStatement(); 

Per risolvere “com.microsoft.sqlserver.jdbc.SQLServerException: l’operazione richiesta non è supportata sui set di risultati solo in avanti” modifica dell’eccezione sopra il codice con

 statement = connection.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY); 

Dopo il cambiamento sopra puoi usare

 int size = 0; try { resultSet.last(); size = resultSet.getRow(); resultSet.beforeFirst(); } catch(Exception ex) { return 0; } return size; 

per ottenere il conteggio delle righe

 Statement s = cd.createStatement(); ResultSet r = s.executeQuery("SELECT COUNT(*) AS rowcount FROM FieldMaster"); r.next(); int count = r.getInt("rowcount"); r.close(); System.out.println("MyTable has " + count + " row(s)."); 

A volte, JDBC non supporta il seguente metodo, ad esempio “TYPE_FORWARD_ONLY” utilizza questa soluzione

Sqlite non supporta in JDBC.

 resultSet.last(); size = resultSet.getRow(); resultSet.beforeFirst(); 

Quindi in quel momento usa questa soluzione.

Grazie..

Effettua invece una query SELECT COUNT(*) FROM ...

Ho appena fatto un metodo getter.

 public int getNumberRows(){ try{ statement = connection.creatStatement(); resultset = statement.executeQuery("your query here"); if(resultset.last()){ return resultset.getRow(); } else { return 0; //just cus I like to always do some kinda else statement. } } catch (Exception e){ System.out.println("Error getting row count"); e.printStackTrace(); } return 0; } 

La tua funzione restituirà la dimensione di un ResultSet, ma il suo cursore verrà impostato dopo l’ultimo record, quindi senza riavvolgerlo chiamando beforeFirst (), first () o previous () non sarai in grado di leggere le sue righe e riavvolgere i metodi non funzioneranno con forward solo ResultSet (otterrai la stessa eccezione che stai ricevendo nel tuo secondo frammento di codice).

La maggior parte dei driver supporta solo il set di risultati, quindi il metodo come last, beforeFirst etc non è supportato.

Il primo approccio è adatto se si stanno anche ottenendo i dati nello stesso ciclo, altrimenti il ​​risultato Set è già stato iterato e non può essere riutilizzato.

Nella maggior parte dei casi il requisito è quello di ottenere il numero di righe restituite da una query senza recuperare le righe. L’iterazione del set di risultati per trovare il conteggio delle righe è quasi uguale all’elaborazione dei dati. È preferibile eseguire un’altra query di conteggio (*).

Altri hanno già risposto come risolvere il tuo problema, quindi non ripeterò ciò che è già stato detto, ma dirò questo: dovresti probabilmente trovare un modo per risolvere i tuoi problemi senza conoscere il conteggio dei risultati prima di leggere risultati.

Ci sono pochissime circostanze in cui il conteggio delle righe è effettivamente necessario prima di leggere il set di risultati, specialmente in un linguaggio come Java. L’unico caso in cui penso sia necessario un conteggio delle righe è quando il conteggio delle righe è l’unico dato necessario (nel qual caso una query di conteggio sarebbe superiore). In caso contrario, è meglio utilizzare un object wrapper per rappresentare i dati della tabella e archiviare questi oggetti in un contenitore dinamico come ArrayList. Quindi, una volta che il set di risultati è stato ripetuto, è ansible ottenere il conteggio degli elenchi di array. Per ogni soluzione che richiede di conoscere il conteggio delle righe prima di leggere il set di risultati, è probabile che tu possa pensare a una soluzione che lo faccia senza conoscere il conteggio delle righe prima di leggere senza troppi sforzi. Pensando a soluzioni che ignorano la necessità di conoscere il conteggio delle righe prima dell’elaborazione, si salva il ResultSet il problema di scorrere fino alla fine del set di risultati, quindi tornare all’inizio (che può essere un’operazione MOLTO costosa per set di risultati di grandi dimensioni) .

Ora, naturalmente, non sto dicendo che non ci sono mai situazioni in cui potresti aver bisogno del conteggio delle righe prima di leggere un set di risultati. Sto solo dicendo che nella maggior parte dei casi, quando le persone pensano di aver bisogno del conteggio dei risultati prima di leggerlo, probabilmente non lo fanno, e vale la pena impiegare 5 minuti per pensare se c’è un altro modo.

Volevo solo offrire i miei 2 centesimi sull’argomento.

Se si dispone di una tabella e si memorizza l’ID come primario e incremento automatico, funzionerà

Esempio di codice per ottenere il numero totale di righe http://www.java2s.com/Tutorial/Java/0340__Database/GettheNumberofRowsinaDatabaseTable.htm

Di seguito è riportato il codice

 import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.Statement; public class Main { public static void main(String[] args) throws Exception { Connection conn = getConnection(); Statement st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE); st.executeUpdate("create table survey (id int,name varchar(30));"); st.executeUpdate("insert into survey (id,name ) values (1,'nameValue')"); st.executeUpdate("insert into survey (id,name ) values (2,null)"); st.executeUpdate("insert into survey (id,name ) values (3,'Tom')"); st = conn.createStatement(); ResultSet rs = st.executeQuery("SELECT * FROM survey"); rs = st.executeQuery("SELECT COUNT(*) FROM survey"); // get the number of rows from the result set rs.next(); int rowCount = rs.getInt(1); System.out.println(rowCount); rs.close(); st.close(); conn.close(); } private static Connection getConnection() throws Exception { Class.forName("org.hsqldb.jdbcDriver"); String url = "jdbc:hsqldb:mem:data/tutorial"; return DriverManager.getConnection(url, "sa", ""); } } 

Il ResultSet ha i suoi metodi che muovono il cursore avanti e indietro a seconda dell’opzione fornita. Per impostazione predefinita, si sposta in avanti (TYPE_FORWARD_ONLY tipo di set di risultati). A meno che CONSTANTS indichi Scrollability e Update of resultset correttamente, si potrebbe finire per ottenere un errore. Ad esempio beforeLast () Questo metodo non ha effetto se il set di risultati non contiene righe. Genera errore se non è TYPE_FORWARD_ONLY.

Il modo migliore per verificare se le righe vuote sono state recuperate — Solo per inserire un nuovo record dopo aver verificato la non esistenza

 if( rs.next() ){ Do nothing } else { No records fetched! } 

Vedi qui

Ecco un codice che evita di ottenere il conteggio per creare un’istanza di un array, ma utilizza invece un ArrayList e, appena prima di restituire, converte ArrayList nel tipo di array necessario.

Si noti che la class Supervisor implementa l’interfaccia ISupervisor, ma in Java non è ansible eseguire il cast da object [] (che restituisce il metodo plain toArray () di ArrayList) a ISupervisor [] (come penso si possa fare in C #), quindi devono scorrere tutti gli elementi dell’elenco e popolare l’array di risultati.

 /** * Get Supervisors for given program id * @param connection * @param programId * @return ISupervisor[] * @throws SQLException */ public static ISupervisor[] getSupervisors(Connection connection, String programId) throws SQLException { ArrayList supervisors = new ArrayList(); PreparedStatement statement = connection.prepareStatement(SQL.GET_SUPERVISORS); try { statement.setString(SQL.GET_SUPERVISORS_PARAM_PROGRAMID, programId); ResultSet resultSet = statement.executeQuery(); if (resultSet != null) { while (resultSet.next()) { Supervisor s = new Supervisor(); s.setId(resultSet.getInt(SQL.GET_SUPERVISORS_RESULT_ID)); s.setFirstName(resultSet.getString(SQL.GET_SUPERVISORS_RESULT_FIRSTNAME)); s.setLastName(resultSet.getString(SQL.GET_SUPERVISORS_RESULT_LASTNAME)); s.setAssignmentCount(resultSet.getInt(SQL.GET_SUPERVISORS_RESULT_ASSIGNMENT_COUNT)); s.setAssignment2Count(resultSet.getInt(SQL.GET_SUPERVISORS_RESULT_ASSIGNMENT2_COUNT)); supervisors.add(s); } resultSet.close(); } } finally { statement.close(); } int count = supervisors.size(); ISupervisor[] result = new ISupervisor[count]; for (int i=0; i 

Seguendo due opzioni ha funzionato per me:

1) Una funzione che restituisce il numero di righe nel ResultSet.

 private int resultSetCount(ResultSet resultSet) throws SQLException{ try{ int i = 0; while (resultSet.next()) { i++; } return i; } catch (Exception e){ System.out.println("Error getting row count"); e.printStackTrace(); } return 0; } 

2) Creare una seconda istruzione SQL con l’opzione COUNT.

Da http://docs.oracle.com/javase/1.4.2/docs/api/java/sql/ResultSetMetaData.html

  ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM TABLE2"); ResultSetMetaData rsmd = rs.getMetaData(); int numberOfColumns = rsmd.getColumnCount(); 

Un ResultSet contiene metadati che forniscono il numero di righe.