dbReadTable-methods         package:RSQLite         R Documentation

_C_o_n_v_e_n_i_e_n_c_e _f_u_n_c_t_i_o_n_s _f_o_r _I_m_p_o_r_t_i_n_g/_E_x_p_o_r_t_i_n_g _D_B_M_S _t_a_b_l_e_s

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

     These functions mimic their R/S-Plus counterpart  'get', 'assign',
     'exists',  'remove', and 'objects', except that they generate code
     that gets remotely executed in a database engine.

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

     A data.frame in the case of 'dbReadTable'; otherwise a logical 
     indicating whether the operation was successful.

_M_e_t_h_o_d_s:

     _c_o_n_n an 'SQLiteConnection' database connection object.

     _n_a_m_e a character string specifying a table name.

     _v_a_l_u_e a data.frame (or coercible to data.frame) object  or a file
          name (character).  In the first case, the data.frame is
          written to a temporary file and then imported to SQLite; when
          'value' is a character, it is interpreted as a file name and
          its contents imported to SQLite.

     _r_o_w._n_a_m_e_s in the case of 'dbReadTable', this argument can be a
          string or an index specifying the column in the DBMS table to
          be used as  'row.names' in the output data.frame (a 'NULL',
          '""', or 0  specifies that no column should be used as
          'row.names' in the output).

          In the case of 'dbWriteTable', this argument should be a
          logical specifying whether the 'row.names' should be output
          to the output DBMS table; if 'TRUE', an extra field whose
          name will be  whatever the R/S-Plus identifier '"row.names"'
          maps to the DBMS (see 'make.db.names').

     _o_v_e_r_w_r_i_t_e a logical specifying whether to overwrite an existing
          table or not.  Its default is 'FALSE'.  (See the BUGS section
          below).

     _a_p_p_e_n_d a logical specifying whether to append to an existing table
          in the DBMS.  Its default is 'FALSE'.

     ...  optional arguments.

          When 'dbWriteTable' is used to import data from a file,  you
          may optionally specify 'header=', 'row.names=', 'col.names=',
          'sep=', 'eol=', 'field.types=',  and 'skip='.

          'header' is a logical indicating whether the first data line
          (but see 'skip') has a header or not.  If missing, it value
          is determined following 'read.table' convention, namely, it
          is set to TRUE if and only if the first row has one fewer
          field that the number of columns.

          'row.names' is a logical to specify whether the first column
          is a set of row names.  If missing its defualt follows the 
          'read.table' convention.

          'col.names' a character vector with column names (these names
          will be filtered with 'make.db.names' to  ensure valid SQL
          identifiers. (See also 'field.types' below.)

          The field separator 'sep=' defaults to '',''.

          The end-of-line delimiter 'eol' defaults to ''\n''.

          'skip' specifies number of lines to skip before reading the
          data and it defaults to 0. 

          'field.types' is a list of named field SQL types where 
          'names(field.types)' provide the new table's column names 
          (if missing, field types are inferred using 'dbDataType').

_B_U_G_S:

     These RSQLite methods do not use transactions, thus it is
     dangerous  to specify 'overwrite=TRUE' in 'dbWriteTable' (the
     table is first removed and in case the data exporting fails the
     original table is lost forever).

_N_o_t_e:

     Note that the data.frame returned by 'dbReadTable' only has
     primitive data, e.g., it does not coerce character data to
     factors.

     SQLite table names are _not_ case sensitive, e.g., table names
     'ABC' and 'abc' are considered equal.

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

     See the Database Interface definition document 'DBI.pdf' in the
     base directory of this package or <URL:
     http://stat.bell-labs.com/RS-DBI>.

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

     'sqliteImportFile', 'SQLite', 'dbDriver', 'dbConnect',
     'dbSendQuery', 'dbGetQuery', 'fetch', 'dbCommit', 'dbGetInfo',
     'dbListTables', 'dbReadTable'.

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

     ## Not run: 
     conn <- dbConnect("SQLite", dbname = "sqlite.db")
     if(dbExistsTable(con, "fuel_frame")){
        dbRemoveTable(conn, "fuel_frame")
        dbWriteTable(conn, "fuel_frame", fuel.frame)
     }
     if(dbExistsTable(conn, "RESULTS")){
        dbWriteTable(conn, "RESULTS", results2000, append = T)
     else
        dbWriteTable(conn, "RESULTS", results2000)
     }
     ## End(Not run)

