Package DBI. February 15, 2013

Transcription

1 Package DBI February 15, 2013 Version Title R Database Interface Author R Special Interest Group on Databases (R-SIG-DB) Maintainer David A. James <daj025@gmail.com> Depends R (>= 2.3.0), methods Imports methods A database interface (DBI) definition for communication between R and relational database management systems. All classes in this package are virtual and need to be extended by the various R/DBMS implementations. LazyLoad yes License LGPL (>= 2) Collate DBI.R Util.R zzz.r Repository CRAN Date/Publication :54:43 NeedsCompilation no R topics documented: dbcallproc dbcommit dbconnect dbdatatype dbdriver dbgetinfo DBIConnection-class DBIDriver-class

2 2 dbcallproc DBIObject-class DBIResult-class dblisttables dbreadtable dbsendquery dbsetdatamappings fetch make.db.names print.list.pairs Index 26 dbcallproc Call an SQL stored procedure Calls a stored procedure on a remote RDBMS dbcallproc(conn,...) Arguments conn a DBIConnection object.... additional arguments are passed to the implementing method. Details Not yet implemented.

3 dbcommit 3 dbcommit DBMS Transaction Management Commit/rollback SQL transactions Arguments dbcommit(conn,...) dbrollback(conn,...) conn Details Value a DBIConnection object, as produced by the function dbconnect.... any database-specific arguments. Not all database engines implement transaction management, older versions of MySQL, for instance. a logical indicating whether the operation succeeded or not. Side Effects The current transaction on the connections con is committed or rolled back. dbconnect dbsendquery dbgetquery fetch dbcommit dbgetinfo dbreadtable ora <- dbdriver("oracle") con <- dbconnect(ora) rs <- dbsendquery(con, "delete * from PURGE as p where p.wavelength<0.03") if(dbgetinfo(rs, what = "rowsaffected") > 250){ warning("dubious deletion -- rolling back transaction") dbrollback(con)

4 4 dbconnect } dbconnect Create a connection to a DBMS Connect to a DBMS going through the appropriate authorization procedure. Arguments drv dbconnect(drv,...) dbdisconnect(conn,...) conn Details Value an object that inherits from DBIDriver, a character string specifying the DBMS driver, e.g., "RPgSQL", "ROracle", "Informix", or possibly another dbconnect object. a connection object as produced by dbconnect.... authorization arguments needed by the DBMS instance; these typically include user, password, dbname, host, port, etc. For details see the appropriate DBIDriver. Some implementations may allow you to have multiple connections open, so you may invoke this function repeatedly assigning its output to different objects. The authorization mechanism is left unspecified, so check the documentation of individual drivers for details. An object that extends DBIConnection in a database-specific manner. For instance dbconnect("mysql") produces an object of class MySQLConnection. This object is used to direct commands to the database engine. dbdisconnect returns a logical value indicating whether the operation succeeded or not. Side Effects notes A connection between R/Splus and the database server is established, and the R/Splus program becomes a client of the database engine. Typically the connections is through the TCP/IP protocol, but this will depend on vendor-specific details. Make sure you close the connection using dbdisconnect(conn) when it is not longer needed.

5 dbdatatype 5 dbconnect dbsendquery dbgetquery fetch dbcommit dbgetinfo dbreadtable # create an RODBC instance and create one connection. m <- dbdriver("rodbc") # open the connection using user, passsword, etc., as # specified in the file \file{$home/.my.cnf} con <- dbconnect(m, dsn="data.source", uid="user", pwd="password")) # Run an SQL statement by creating first a resultset object rs <- dbsendquery(con, statement = paste( "SELECT w.laser_id, w.wavelength, p.cut_off", "FROM WL w, PURGE P", "WHERE w.laser_id = p.laser_id", "SORT BY w.laser_id") # we now fetch records from the resultset into a data.frame data <- fetch(rs, n = -1) # extract all rows dim(data) dbdatatype Determine the SQL Data Type of an S object Determine an (approximately) appropriate SQL data type for an S object. dbdatatype(dbobj, obj,...) Arguments dbobj a DBIDriver object, e.g., ODBCDriver, OracleDriver. obj R/Splus object whose SQL type we want to determine.... any other parameters that individual methods may need.

6 6 dbdriver Details This is a generic function. The default method determines the SQL type of an R/Splus object according to the SQL 92 specification, which may serve as a starting point for driver implementations. Value A character string specifying the SQL data type for obj. issqlkeyword make.db.names ora <- dbdriver("oracle") sql.type <- dbdatatype(ora, x) dbdriver Database Interface (DBI) Classes and drivers These virtual classes and their methods define the interface to database management systems (DBMS). They are extended by packages or drivers that implement the methods in the context of specific DBMS (e.g., Berkeley DB, MySQL, Oracle, ODBC, PostgreSQL, SQLite). dbdriver(drvname,...) dbunloaddriver(drv,...) ## free up all resources Arguments drvname character name of the driver to instantiate. drv an object that inherits from DBIDriver as created by dbdriver.... any other arguments are passed to the driver drvname.

7 dbdriver 7 Details Value The virtual class DBIDriver defines the operations for creating connections and defining data type mappings. Actual driver classes, for instance RPgSQL, RMySQL, etc. implement these operations in a DBMS-specific manner. More generally, the DBI defines a very small set of classes and methods that allows users and applications access DBMS with a common interface. The virtual classes are DBIDriver that individual drivers extend, DBIConnection that represent instances of DBMS connections, and DBIResult that represent the result of a DBMS statement. These three classes extend the basic class of DBIObject, which serves as the root or parent of the class hierarchy. In the case of dbdriver, an driver object whose class extends DBIDriver. This object may be used to create connections to the actual DBMS engine. In the case of dbunloaddriver, a logical indicating whether the operation succeeded or not. Side Effects The client part of the database communication is initialized (typically dynamically loading C code, etc.) but note that connecting to the database engine itself needs to be done through calls to dbconnect. dbconnect, dbsendquery, dbgetquery, fetch, dbcommit, dbgetinfo, dblisttables, dbreadtable. # create a MySQL instance for capacity of up to 25 simultaneous # connections. m <- dbdriver("mysql", max.con = 25) p <- dbdriver("pgsql") # open the connection using user, password, etc., as con <- dbconnect(m, user="ip", password = "traffic", dbname="iptraffic") rs <- dbsubmitquery(con, "select * from HTTP_ACCESS where IP_ADDRESS = ") df <- fetch(rs, n = 50) df2 <- fetch(rs, n = -1) dbclearresult(rs) pcon <- dbconnect(p, "user", "password", "dbname") dblisttables(pcon)

8 8 dbgetinfo dbgetinfo Database interface meta-data Extract meta-data associated with various objects Arguments dbgetinfo(dbobj,...) # meta-data for any DBIObject dbgetdbiversion() # DBI version dbgetstatement(res,...) # statement that produced result "res" dbgetrowcount(res,...) # number of rows fetched so far dbgetrowsaffected(res,...) # number of affected rows (e.g., DELETE) dbcolumninfo(res,...) # result set data types dbhascompleted(res,...) # are there more rows to fetch on "res"? dbobj res Details Value any object that implements some functionality in the R/Splus interface to databases (a driver, a connection or a result set). refers to a DBIResult object.... any driver-specific arguments. These functions implement a minimal set of meta-data describing the most important aspects of the R/Splus to DBMS interface. The dbgetinfo works very similarly to the function options in that it attempts to extract what the user may request, possibly NULL if it can t locate the specific piece of meta-data. dbgetdbiversion returns a character string with the version of the database interface API. dbgetinfo produces either a character vector or a named list of (name, value) pairs. dbgetstatement returns a character string with the statement associated with the result set res. dbgetrowcount returns the number of rows fetched so far. dbgetrowsaffected returns the number of affected rows (e.g., how many rows were deleted, inserted). Some drivers may set this to the total number of rows a query produces. dbcolumninfo returns a data.frame with one row per output field in res. The columns should report field name, field data type, scale and precision (as understood by the DBMS engine), whether the field can store NULL values, and possibly other DBMS-specific information. dbhascompleted a logical describing whether the operations has been completed by the DBMS or not.

9 DBIConnection-class 9 Note Meta-data associated with a driver should include the version of the package, plus the version of the underlying client library. Connection objects should report the version of the DBMS engine, database name, user, possibly password, etc. Results should include the statement being executed, how many rows have been fetched so far (in the case of queries), how many rows were affected (deleted, inserted, changed, or total number of records to be fetched). dbdriver, dbconnect, dbsendquery, dbgetquery, fetch, dbcommit, dbgetinfo, dblisttables, dbreadtable. drv <- dbdriver("sqlite") con <- dbconnect(drv) dblisttables(con) rs <- dbsendquery(con, query.sql) dbgetstatement(rs) dbhascompleted(rs) info <- dbgetinfo(rs) names(dbgetinfo(drv)) # DBIConnection info names(dbgetinfo(con)) # DBIResult info names(dbgetinfo(rs)) DBIConnection-class Class DBIConnection Base class for all DBMS connection classes. Individual drivers (ODBC, Oracle, PostgreSQL, MySQL, etc.) extend this class in a database-specific manner.

10 10 DBIConnection-class Objects from the Class Extends A virtual Class: No objects may be created from it. Class "DBIObject", directly. Generator The main generator is dbconnect. Methods The following methods take objects from classes derived from DBIConnection: Create and close connections: dbconnect signature(drv = "DBIConnection"):... dbdisconnect signature(conn = "DBIConnection"):... Execute SQL commands: dbsendquery signature(conn = "DBIConnection", statement = "character"):... dbgetquery signature(conn = "DBIConnection", statement = "character"):... dbcallproc signature(conn = "DBIConnection"):... Transaction management: dbcommit signature(conn = "DBIConnection"):... dbrollback signature(conn = "DBIConnection"):... Meta-data: dblistresults signature(conn = "DBIConnection"):... dbgetinfo signature(dbobj = "DBIConnection"):... summary signature(object = "DBIConnection"):... Exceptions: dbgetexception signature(conn = "DBIConnection"):... dblistfields signature(conn = "DBIConnection", name = "character"):... Convenience functions: dblisttables signature(conn = "DBIConnection"):... dbreadtable signature(conn = "DBIConnection", name = "character"):... dbexiststable signature(conn = "DBIConnection", name = "character"):... dbremovetable signature(conn = "DBIConnection", name = "character"):... dbwritetable signature(conn = "DBIConnection", name = "character", value = "data.frame"):... Author(s) R-SIG-DB

11 DBIDriver-class 11 DBI classes: DBIObject-class DBIDriver-class DBIConnection-class DBIResult-class ora <- dbdriver("oracle") con <- dbconnect(ora, pg <- dbdriver("postgresql") con <- dbconnect(pg, "user", "password") DBIDriver-class Class DBIDriver Base class for all DBMS drivers (e.g., ODBC, Oracle, MySQL, PostgreSQL). Objects from the Class A virtual Class: No objects may be created from it. Extends Class "DBIObject", directly. Generator The generator for classes that extend DBIDriver is dbdriver. Methods The following methods are defined for classes that extend DBIDriver: dbunloaddriver signature(drv = "DBIDriver"):... dbconnect signature(drv = "DBIDriver"):... dbgetinfo signature(dbobj = "DBIDriver"):... dblistconnections signature(drv = "DBIDriver"):... summary signature(object = "DBIDriver"):...

12 12 DBIObject-class Author(s) R-SIG-DB DBI classes: DBIObject-class DBIDriver-class DBIConnection-class DBIResult-class The function dbconnect is the main generator. In addition see the help of the methods above. drv <- dbdriver("odbc") summary(drv) dblistconnections(drv) DBIObject-class Class DBIObject Base class for all other DBI classes (e.g., drivers, connections). Objects from the Class A virtual Class: No objects may be created from it. Methods Methods defined for classes that extend DBIObject: dbdatatype signature(dbobj = "DBIObject"):... issqlkeyword signature(dbobj = "DBIObject"):... make.db.names signature(dbobj = "DBIObject"):... SQLKeywords signature(dbobj = "DBIObject"):... summary signature(object = "DBIObject"):... Plus many other specific to the other DBI classes.

13 DBIResult-class 13 Author(s) R-SIG-DB DBI classes: DBIObject-class DBIDriver-class DBIConnection-class DBIResult-class drv <- dbdriver("mysql") con <- dbconnect(drv, group = "rs-dbi") res <- dbsendquery(con, "select * from vitalsuite") is(drv, "DBIObject") ## True is(con, "DBIObject") ## True is(res, "DBIObject") DBIResult-class Class DBIResult Base class for all DBMS-specific result objects. Objects from the Class A virtual Class: No objects may be created from it. Extends Class "DBIObject", directly. Generator The main generator is dbsendquery.

14 14 DBIResult-class Methods Fetching methods: signature(res = "DBIResult", n = "numeric"):... fetch signature(res = "DBIResult", n = "missing"):... Close result set: dbclearresult signature(res = "DBIResult"):... Meta-data: dbcolumninfo signature(res = "DBIResult"):... dbgetexception signature(conn = "DBIResult"):... dbgetinfo signature(dbobj = "DBIResult"):... dbgetrowcount signature(res = "DBIResult"):... dbgetrowsaffected signature(res = "DBIResult"):... dbgetstatement signature(res = "DBIResult"):... dbhascompleted signature(res = "DBIResult"):... dblistfields signature(conn = "DBIResult", name = "missing"):... summary signature(object = "DBIResult"):... coerce signature(from = "DBIConnection", to = "DBIResult"):... Author(s) R-SIG-DB DBI classes: DBIObject-class DBIDriver-class DBIConnection-class DBIResult-class drv <- dbdriver("oracle") con <- dbconnect(drv, "user/password@dbname") res <- dbsendquery(con, "select * from LASERS where prdata > ") summary(res) while(dbhascompleted(res)){ chunk <- fetch(res, n = 1000) process(chunk) }

15 dblisttables 15 dblisttables List items from a remote DBMS and from objects that implement the database interface DBI. List remote tables, fields of a remote table, opened connections and pending statements in a connection. dblisttables(conn,...) dblistfields(conn, name,...) dblistconnections(drv,...) dblistresults(conn,...) Arguments drv a driver object (e.g., ODBC, Oracle) conn a connection object name a character string with the name of the remote table.... optional arguments for the actual driver implementation. Value dblisttables returns a character vector with the names of the tables in the remote database associated with the connection in conn object. dblistfields returns a character vector with the names of the fields of the res result object (it must be a query statement). dblistconnections returns a list of all currently open connections on driver drv. Drivers that implement single connections would return the one single connection object. dblistresults returns a list of objects for all pending results (statements) on the conn connection. dbgetinfo, dbcolumninfo, dbdriver, dbconnect, dbsendquery

16 16 dbreadtable odbc <- dbdriver("odbc") # after working awhile... for(con in dblistconnections(odbc)){ dbgetstatement(dblistresults(con)) } dbreadtable Convenience functions for Importing/Exporting DBMS tables These functions mimic their R/Splus counterpart get, assign, exists, remove, and objects, except that they generate code that gets remotely executed in a database engine. Arguments dbreadtable(conn, name,...) dbwritetable(conn, name, value,...) dbexiststable(conn, name,...) dbremovetable(conn, name,...) dbreadtable(conn, name, row.names = "row_names",...) dbwritetable(conn, name, value, row.names = T,..., overwrite = F, append = F) dbexiststable(conn, name,...) dbremovetable(conn, name,...) conn name value row.names a database connection object. a character string specifying a DBMS table name. a data.frame (or coercible to data.frame). 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, the extra field name will be whatever the S identifier "row.names" maps to the DBMS (see make.db.names).

17 dbreadtable 17 Value overwrite append a logical specifying whether to overwrite an existing table or not. Its default is FALSE. a logical specifying whether to append to an existing table in the DBMS. Its default is FALSE.... any optional arguments that the underlying database driver supports. dbreadtable returns a data.frame; all other functions return TRUE or FALSE denoting whether the operation was successful or not. Side Effects Note A DBMS statement is generated and remotely executed on a database engine; the result set it produces is fetched in its entirety. These operations may failed if the underlying database driver runs out of available connections and/or result sets, or the operation violates DBMS integrity constraints (e.g., attempting to write duplicate values on a field that s defined as a primary key). The semantics of assign are slightly extended to allow overwriting or appending to an existing table. The translation of identifiers between R/Splus and SQL is done through calls to make.names and make.db.names, but we cannot guarantee that the conversion is reversible. For details see make.db.names. dbdriver, dbconnect, dbsendquery, dbgetquery, fetch, dbcommit, dbgetinfo, dblisttables, dbreadtable. conn <- dbconnect("mysql", group = "vitalanalysis") con2 <- dbconnect("odbc", "dsn", "user", "pwd") if(dbexiststable(con2, "fuel_frame")){ fuel.frame <- dbreadtable(con2, "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) }

18 18 dbsendquery dbsendquery Execute a statement on a given database connection Submits and executes an arbitrary SQL statement on a specific connection. Also, clears (closes) a result set. dbsendquery(conn, statement,...) dbgetquery(conn, statement,...) dbclearresult(res,...) dbgetexception(conn,...) Arguments conn statement res Details Value a connection object. a character vector of length 1 with the SQL statement. a result set object (i.e., the value of dbsendquery).... database-specific parameters may be specified. The function dbsendquery only submits and synchronously executes the SQL statement to the database engine. It does not extracts any records for that you need to use the function fetch (make sure you invoke dbclearresult when you finish fetching the records you need). The function dbgetquery does all these in one operation (submits the statement, fetches all output records, and clears the result set). dbclearresult frees all resources (local and remote) associated with a result set. It some cases (e.g., very large result sets) this can be a critical step to avoid exhausting resources (memory, file descriptors, etc.) dbsendquery returns a result set object, i.e., an object that inherits from DBIResult; if the statement generates output (e.g., a SELECT statement) the result set can be used with fetch to extract records. dbgetquery returns a data.frame with the output (if any) of the query. dbclearresult returns a logical indicating whether clearing the result set was successful or not. dbgetexception returns a list with elements errnum (an integer error number) and errmsg (a character string) describing the last error in the connection conn.

19 dbsetdatamappings 19 Side Effects The statement is submitted for synchronous execution to the server connected through the conn object. The DBMS executes the statement, possibly generating vast amounts of data. Where these data reside is driver-specific: some drivers may choose to leave the output on the server and transfer them piecemeal to R/Splus, others may transfer all the data to the client but not necessarily to the memory that R/Splus manages. See the individual drivers dbsendquery method for implementation details. dbdriver dbconnect fetch dbcommit dbgetinfo dbreadtable drv <- dbdriver("mysql") con <- dbconnect(drv) res <- dbsendquery(con, "SELECT * from liv25") data <- fetch(res, n = -1) dbsetdatamappings Set data mappings between an DBMS and R/Splus Sets one or more conversion functions to handle the translation of DBMS data types to R/Splus objects. This is only needed for non-primitive data, since all DBI drivers handle the common base types (integers, numeric, strings, etc.) dbsetdatamappings(res, flds,...) Arguments res a DBIResult object as returned by dbsendquery. flds a field description object as returned by dbcolumninfo.... any additional arguments are passed to the implementing method.

20 20 dbsetdatamappings Details The details on conversion functions (e.g., arguments, whether they can invoke initializers and/or destructors) have not been specified. Value a logical specifying whether the conversion functions were successfully installed or not. Side Effects Conversion functions are set up to be invoked for each element of the corresponding fields in the result set. Note No driver has yet implemented this functionality. dbsendquery, fetch, dbcolumninfo. makeimage <- function(x) {.C("make_Image", as.integer(x), length(x)) } res <- dbsendquery(con, statement) flds <- dbcolumninfo(res) flds[3, "Sclass"] <- makeimage dbsetdatamappings(rs, flds) im <- fetch(rs, n = -1)

21 fetch 21 fetch Fetch records from a previously executed query Fetch records from a previously executed query. fetch(res, n,...) Arguments res n Details a result set object (one whose class extends DBIResult). This object needs to be the result of a statement that produces output, such as SQL s SELECT or SELECTlike statement, this object res is typically produced by a call to or dbsendquery. maximum number of records to retrieve per fetch. Use n = -1 to retrieve all pending records. Some implementations may recognize other special values.... any other database-engine specific arguments. See the notes for the various database server implementations. Value a data.frame with as many rows as records were fetched and as many columns as fields in the result set. Side Effects As the R/Splus client fetches records the remote database server updates its cursor accordingly. Note Make sure you close the result set with dbclearresult as soon as you finish retrieving the records you want. dbconnect, dbsendquery, dbgetquery, dbclearresult, dbcommit, dbgetinfo, dbreadtable.

22 22 make.db.names # Run an SQL statement by creating first a resultset object drv <- dbdriver("odbc") con <- dbconnect(drv,...) res <- dbsendquery(con, statement = paste( "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")) # we now fetch the first 100 records from the resultset into a data.frame data1 <- fetch(res, n = 100) dim(data1) dbhascompleted(res) # let s get all remaining records data2 <- fetch(res, n = -1) make.db.names Make R/Splus identifiers into legal SQL identifiers Produce legal SQL identifiers from a character vector. Arguments make.db.names(dbobj, snames, keywords, unique=true, allow.keywords=true,...) SQLKeywords(dbObj,...) issqlkeyword(dbobj, name, keywords=.sql92keywords, case=c("lower", "upper", "any")[3],...) dbobj snames name unique allow.keywords any DBI object (e.g., DBIDriver). a character vector of R/Splus identifiers (symbols) from which we need to make SQL identifiers. a character vector with database identifier candidates we need to determine whether they are legal SQL identifiers or not. logical describing whether the resulting set of SQL names should be unique. Its default is TRUE. Following the SQL 92 standard, uniqueness of SQL identifiers is determined regardless of whether letters are upper or lower case. logical describing whether SQL keywords should be allowed in the resulting set of SQL names. Its default is TRUE

23 make.db.names 23 keywords case Details Value Bugs a character vector with SQL keywords, by default it s.sql92keywords defined by the DBI. a character string specifying whether to make the comparison as lower case, upper case, or any of the two. it defaults to any.... any other argument are passed to the driver implementation. The algorithm in make.db.names first invokes make.names and then replaces each occurrence of a dot. by an underscore \_. If allow.keywords is FALSE and identifiers collide with SQL keywords, a small integer is appended to the identifier in the form of "_n". The set of SQL keywords is stored in the character vector.sql92keywords and reflects the SQL ANSI/ISO standard as documented in "X/Open SQL and RDA", 1994, ISBN Users can easily override or update this vector. make.db.names returns a character vector of legal SQL identifiers corresponding to its snames argument. SQLKeywords returns a character vector of all known keywords for the database-engine associated with dbobj. issqlkeyword returns a logical vector parallel to name. The current mapping is not guaranteed to be fully reversible: some SQL identifiers that get mapped into S identifiers with make.names and then back to SQL with make.db.names will not be equal to the original SQL identifiers (e.g., compound SQL identifiers of the form username.tablename will loose the dot. ). The set of SQL keywords is stored in the character vector.sql92keywords and reflects the SQL ANSI/ISO standard as documented in "X/Open SQL and RDA", 1994, ISBN Users can easily override or update this vector. dbreadtable, dbwritetable, dbexiststable, dbremovetable, dblisttables. # This example shows how we could export a bunch of data.frames # into tables on a remote database.

24 24 print.list.pairs con <- dbconnect("oracle", user="iptraffic", pass = pwd) export <- c("trantime. ", "trantime.print", "round.trip.time. ") tabs <- make.db.names(export, unique = T, allow.keywords = T) for(i in seq(along = export) ) dbwritetable(con, name = tabs[i], get(export[i])) # Oracle s extensions to SQL keywords oracle.keywords <- c("cluster", "COLUMN", "MINUS", "DBNAME") issqlkeyword(nam, c(.sql92keywords, oracle.keywords)) [1] T T T F print.list.pairs Support functions Some of these functions are conditionally elevated to generic functions (e.g., print, summary). Others are low-level support functions. print.list.pairs(x,...) Arguments x a list of key, value pairs... additional arguments to be passed to cat Value the (invisible) value of x. print.default, summary.default, cat.

25 print.list.pairs 25 print.list.pairs(list(a =1, b = 2))

26 Index Topic classes DBIConnection-class, 9 DBIDriver-class, 11 DBIObject-class, 12 DBIResult-class, 13 Topic database dbcallproc, 2 dbcommit, 3 dbconnect, 4 dbdatatype, 5 dbdriver, 6 dbgetinfo, 8 DBIConnection-class, 9 DBIDriver-class, 11 DBIObject-class, 12 DBIResult-class, 13 dblisttables, 15 dbreadtable, 16 dbsendquery, 18 dbsetdatamappings, 19 fetch, 21 make.db.names, 22 print.list.pairs, 24 Topic interface dbcallproc, 2 dbcommit, 3 dbconnect, 4 dbdatatype, 5 dbdriver, 6 dbgetinfo, 8 DBIConnection-class, 9 DBIDriver-class, 11 DBIObject-class, 12 DBIResult-class, 13 dblisttables, 15 dbreadtable, 16 dbsendquery, 18 dbsetdatamappings, 19 fetch, 21 make.db.names, 22 print.list.pairs, 24 cat, 24 coerce, 14 dbcallproc, 2, 10 dbclearresult, 14, 21 dbclearresult (dbsendquery), 18 dbcolumninfo, 14, 15, 20 dbcolumninfo (dbgetinfo), 8 dbcommit, 3, 3, 5, 7, 9, 10, 17, 19, 21 dbconnect, 3, 4, 5, 7, 9 12, 15, 17, 19, 21 dbdatatype, 5, 12 dbdatatype,dbiobject-method (dbdatatype), 5 dbdatatype.default (dbdatatype), 5 dbdisconnect, 10 dbdisconnect (dbconnect), 4 dbdriver, 6, 9, 11, 15, 17, 19 dbdriver,character-method (dbdriver), 6 dbexiststable, 10, 23 dbexiststable (dbreadtable), 16 dbgetdbiversion (dbgetinfo), 8 dbgetexception, 10, 14 dbgetexception (dbsendquery), 18 dbgetinfo, 3, 5, 7, 8, 9 11, 14, 15, 17, 19, 21 dbgetquery, 3, 5, 7, 9, 10, 17, 21 dbgetquery (dbsendquery), 18 dbgetrowcount, 14 dbgetrowcount (dbgetinfo), 8 dbgetrowsaffected, 14 dbgetrowsaffected (dbgetinfo), 8 dbgetstatement, 14 dbgetstatement (dbgetinfo), 8 dbhascompleted, 14 dbhascompleted (dbgetinfo), 8 DBIConnection-class, 9 DBIDriver-class, 11 DBIObject-class, 12 26

27 INDEX 27 DBIResult-class, 13 dblistconnections, 11 dblistconnections (dblisttables), 15 dblistfields, 10, 14 dblistfields (dblisttables), 15 dblistresults, 10 dblistresults (dblisttables), 15 dblisttables, 7, 9, 10, 15, 17, 23 dbreadtable, 3, 5, 7, 9, 10, 16, 17, 19, 21, 23 dbremovetable, 10, 23 dbremovetable (dbreadtable), 16 dbrollback, 10 dbrollback (dbcommit), 3 dbsendquery, 3, 5, 7, 9, 10, 13, 15, 17, 18, dbsetdatamappings, 19 dbunloaddriver, 11 dbunloaddriver (dbdriver), 6 dbwritetable, 10, 23 dbwritetable (dbreadtable), 16 fetch, 3, 5, 7, 9, 14, 17 20, 21 format (print.list.pairs), 24 issqlkeyword, 6, 12 issqlkeyword (make.db.names), 22 issqlkeyword,dbiobject,character-method (make.db.names), 22 make.db.names, 6, 12, 16, 17, 22, 23 make.db.names,dbiobject,character-method (make.db.names), 22 make.names, 17 print (print.list.pairs), 24 print.default, 24 print.list.pairs, 24 SQLKeywords, 12 SQLKeywords (make.db.names), 22 SQLKeywords,DBIObject-method (make.db.names), 22 SQLKeywords,missing-method (make.db.names), 22 summary, summary (print.list.pairs), 24 summary,dbiobject-method (DBIDriver-class), 11 summary.default, 24