fetch                 package:RMySQL                 R Documentation

_F_e_t_c_h _r_e_c_o_r_d_s _f_r_o_m _a _p_r_e_v_i_o_u_s_l_y _e_x_e_c_u_t_e_d _S_E_L_E_C_T _s_t_a_t_e_m_e_n_t

_D_e_s_c_r_i_p_t_i_o_n:

     Fetch records from a previously executed SELECT statement

_U_s_a_g_e:

     fetch(res, n, ...)

_A_r_g_u_m_e_n_t_s:

resultSet: a `resultSet' object. This object needs to be the result of
          a `SELECT' or `SELECT'-like statement, as produced by
          `dbExec.' or `dbExecStatement.' SQL statements such as
          `INSERT', `DELETE', do not create result sets. 

       n: maximum number of records to retrieve per fetch. Use `n = -1'
          to retrieve all pending records. Some implementations may
          recognize other special values (RS-MySQL interprets `n = 0'
          to mean "use whatever default was set in the call to
          `MySQL'). 

    ... : any other database-engine specific arguments. 

_D_e_t_a_i_l_s:

     See the notes for the various database server implementations.

_V_a_l_u_e:

     a data.frame with as many rows as records  were fetched and as
     many columns as fields in the result set.

_S_i_d_e _E_f_f_e_c_t_s:

     As the R/S client fetches records the remote database server
     updates its cursor accordingly.

_N_o_t_e:

     Make sure you close the result set with `close(resultSet)' as soon
     as you finish retrieving the records you want.

_R_e_f_e_r_e_n_c_e_s:

     See the Omega Project for Statistical Computing (<URL:
     http://www.omegahat.org>) for details on the R/S interface to
     databases.

_S_e_e _A_l_s_o:

     On database managers:

     `dbManager' `MySQL' `load' `unload'

     On connections, SQL statements and resultSets:

     `dbExecStatement' `dbExec' `fetch' `quickSQL'

     On transaction management:

     `commit' `rollback'

     On meta-data:

     `describe' `getVersion' `getDatabases' `getTables' `getFields'
     `getCurrentDatabase' `getTableIndices' `getException'
     `getStatement' `hasCompleted' `getRowCount' `getAffectedRows'
     `getNullOk' `getInfo'

_E_x_a_m_p_l_e_s:

     # Run an SQL statement by creating first a resultSet object
     > m <- MySQL()
     > con <- dbConnect(m)    
     > rs <- dbExecStatement(con, 
              statement = "SELECT w.laser_id, w.wavelength, p.cut_off 
                           FROM WL w, PURGE P
                           WHERE w.laser_id = p.laser_id
                           ORDER BY w.laser_id")
     > rs
     MySQLResultSet id = (12629,1,3)

     # we now fetch the first 100 records from the restulSet into a data.frame
     > data1 <- fetch(rs, n = 100)   
     > dim(data)
     [1] 10  18

     > hasCompleted(rs)
     [1] 0

     # let's get all remaining records
     > data2 <- fetch(rs, n = -1)

