SQLite                package:RSQLite                R Documentation

_I_n_s_t_a_n_t_i_a_t_e _t_h_e _S_Q_L_i_t_e _e_n_g_i_n_e _f_r_o_m _t_h_e _c_u_r_r_e_n_t _R/_S _s_e_s_s_i_o_n.

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

     This function creates and initializes the SQLite engine. It
     returns an object that allows you to connect to the SQLite 
     embedded engine.

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

     SQLite(max.con = 10, fetch.default.rec = 500, force.reload = F)

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

max.con : maximum number of connections that we intended to have open.
          This can be up to 100, a limit defined at compilation time. 

fetch.default.rec: number of records to fetch at one time from the
          database. (The `fetch' method uses this number as a default.) 

force.reload: should we reload (reinitialize) the package code? Setting
          this to `TRUE' allows you to change default settings.  Notice
          that all connections should be closed before re-loading. 

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

     This object is a singleton, that is, on subsequent invocations it
     returns the same initialized object. 

     This implementation allows the R/S embedded SQLite engine to work
     with multiple database instances through multiple connections 
     simultaneously.

     SQLite keeps each database instance in one single file. The name
     of the database is the file name, thus database names should be
     legal file names in the running platform.

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

     An object `SQLiteManager' that extends  `dbManager' and 
     `dbObjectId'. This object is required to create connections to the
     embedded SQLite database. There can be many SQLite database
     instances running simultaneously.

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

     The R/S client part of the database communication is initialized,
     but note that connecting to database instances needs to be done
     through calls to `dbConnect'.

_U_s_e_r _a_u_t_h_e_n_t_i_c_a_t_i_o_n:

     SQLite is a single-user database engine, so it has no concept of
     user.

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

     See the Omega Project for Statistical Computing at <URL:
     http://www.omegahat.org> for more details on the R/S database
     interface.

     See the Adobe PDF file `RS-DBI.pdf' under the `doc' subdirectory
     of this package, i.e.,  `.path.package("RSQLite")/doc/RS-DBI.pdf'.

     See the documentation at the SQLite Web site <URL:
     http://www.hwaci/com/sw/sqlite/index.html> for details.

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

     On database managers:

     `dbManager' `SQLite' `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:

        # create a SQLite instance and create one connection.
        m <- dbManager("SQLite")

        # initialize a new database "base.dbms" in the current directory
        # and copy some data.frame from the base package into it

        con <- dbConnect(m, dbname = "base.dbms")
        data(USArrests)
        assignTable(con, "USArrests", USArrests, overwrite = T)

        # query
        rs <- dbExecStatement(con, "select * from USArrests")
        d1 <- fetch(rs, n = 10)      # extract data in chunks of 10 rows
        hasCompleted(rs)
        d2 <- fetch(rs, n = -1)      # extract all remaining data
        hasCompleted(rs)
        close(rs)
        getTables(con)    


