usable - read access in r

¿Cómo conectar R con la base de datos de Access en la ventana de 64 bits?

Question

Cuando intenté conectar R con la base de datos de Access recibí un error

odbcConnectAccess is only usable with 32-bit Windows

¿Alguien tiene una idea de cómo resolver esto?

library(RODBC) 
mdbConnect<-odbcConnectAccess("D:/SampleDB1/sampleDB1.mdb")

Answer 1

Aquí hay una función única que transferirá datos desde el acceso de 32 bits a 64 bit R sin tener que guardar ningún archivo. La función crea una cadena de expresión que se pasa a una segunda sesión de 32 bits; los datos se devuelven a la sesión original utilizando el paquete del servidor de socket (svSocket). Una cosa a tener en cuenta es que el servidor de socket guarda los datos de acceso en el entorno global, por lo que el segundo parámetro se usa para definir la salida en lugar de usar "<-" para guardar la salida.

access_query_32 <- function(db_table = "qryData_RM", table_out = "data_access") {
  library(svSocket)

  # variables to make values uniform
  sock_port <- 8642L
  sock_con <- "sv_con"
  ODBC_con <- "a32_con"
  db_path <- "~/path/to/access.accdb"

  if (file.exists(db_path)) {

    # build ODBC string
    ODBC_str <- local({
      s <- list()
      s$path <- paste0("DBQ=", gsub("(/|////)+", "/", path.expand(db_path)))
      s$driver <- "Driver={Microsoft Access Driver (*.mdb, *.accdb)}"
      s$threads <- "Threads=4"
      s$buffer <- "MaxBufferSize=4096"
      s$timeout <- "PageTimeout=5"
      paste(s, collapse=";")
    })

    # start socket server to transfer data to 32 bit session
    startSocketServer(port=sock_port, server.name="access_query_32", local=TRUE)

    # build expression to pass to 32 bit R session
    expr <- "library(svSocket)"
    expr <- c(expr, "library(RODBC)")
    expr <- c(expr, sprintf("%s <- odbcDriverConnect(''%s'')", ODBC_con, ODBC_str))
    expr <- c(expr, sprintf("if(''%1$s'' %%in%% sqlTables(%2$s)$TABLE_NAME) {%1$s <- sqlFetch(%2$s, ''%1$s'')} else {%1$s <- ''table %1$s not found''}", db_table, ODBC_con))
    expr <- c(expr, sprintf("%s <- socketConnection(port=%i)", sock_con, sock_port))
    expr <- c(expr, sprintf("evalServer(%s, %s, %s)", sock_con, table_out, db_table))
    expr <- c(expr, "odbcCloseAll()")
    expr <- c(expr, sprintf("close(%s)", sock_con))
    expr <- paste(expr, collapse=";")

    # launch 32 bit R session and run expressions
    prog <- file.path(R.home(), "bin", "i386", "Rscript.exe")
    system2(prog, args=c("-e", shQuote(expr)), stdout=NULL, wait=TRUE, invisible=TRUE)

    # stop socket server
    stopSocketServer(port=sock_port)

    # display table fields
    message("retrieved: ", table_out, " - ", paste(colnames(get(table_out)), collapse=", "))
  } else {
    warning("database not found: ", db_path)
  }
}

Ocasionalmente, esta función devolverá un error, pero no afecta a la recuperación de datos y parece ser el resultado del cierre de la conexión del servidor de socket.

Es probable que haya margen de mejora, pero esto proporciona un método simple y rápido para obtener datos en R desde el acceso de 32 bits.

Answer 2

La función de manotheshark anterior es muy útil, pero quería usar una consulta SQL, en lugar de un nombre de tabla, para acceder a la base de datos y también pasar el nombre de la base de datos como parámetro, ya que normalmente trabajo con varias bases de datos de Access. Aquí hay una versión modificada:

access_sql_32 <- function(db_sql = NULL, table_out = NULL, db_path = NULL) {
  library(svSocket)

  # variables to make values uniform
  sock_port <- 8642L
  sock_con <- "sv_con"
  ODBC_con <- "a32_con"

  if (file.exists(db_path)) {

    # build ODBC string
    ODBC_str <- local({
      s <- list()
      s$path    <- paste0("DBQ=", gsub("(/|////)+", "/", path.expand(db_path)))
      s$driver  <- "Driver={Microsoft Access Driver (*.mdb, *.accdb)}"
      s$threads <- "Threads=4"
      s$buffer  <- "MaxBufferSize=4096"
      s$timeout <- "PageTimeout=5"
      paste(s, collapse=";")
    })

    # start socket server to transfer data to 32 bit session
    startSocketServer(port=sock_port, server.name="access_query_32", local=TRUE)

    # build expression to pass to 32 bit R session
    expr <- "library(svSocket)"
    expr <- c(expr, "library(RODBC)")
    expr <- c(expr, sprintf("%s <- odbcDriverConnect(''%s'')", ODBC_con, ODBC_str))
    expr <- c(expr, sprintf("%1$s <- sqlQuery(%3$s, /"%2$s/")", table_out, db_sql, ODBC_con))
    expr <- c(expr, sprintf("%s <- socketConnection(port=%i)", sock_con, sock_port))
    expr <- c(expr, sprintf("evalServer(%s, %s, %s)", sock_con, table_out, table_out))
    expr <- c(expr, "odbcCloseAll()")
    expr <- c(expr, sprintf("close(%s)", sock_con))
    expr <- paste(expr, collapse=";")

    # launch 32 bit R session and run the expression we built
    prog <- file.path(R.home(), "bin", "i386", "Rscript.exe")
    system2(prog, args=c("-e", shQuote(expr)), stdout=NULL, wait=TRUE, invisible=TRUE)

    # stop socket server
    stopSocketServer(port=sock_port)

    # display table fields
    message("Retrieved: ", table_out, " - ", paste(colnames(get(table_out)), collapse=", "))
  } else {
    warning("database not found: ", db_path)
  }
}

También tuve algunas dificultades para averiguar cómo llamar a la función de manotheshark y me costó profundizar en la documentación del paquete svSocket para darme cuenta de que el script de llamada necesita crear una instancia del objeto en el que se devolverán los datos y luego pasar su NAME (no el objeto sí mismo) en el parámetro table_out. Aquí hay un ejemplo de un R-script que llama a mi versión modificada:

source("scripts/access_sql_32.R")
spnames <- data.frame()
# NB. use single quotes for any embedded strings in the SQL
sql <- "SELECT name as species FROM checklist 
        WHERE rank = ''species'' ORDER BY name"
access_sql_32(sql, "spnames", "X:/path/path/mydata.accdb")

Esto funciona, pero tiene limitaciones.

En primer lugar, evite cualquier extensión SQL de Microsoft Access. Por ejemplo, si utiliza el constructor Consulta de acceso, a menudo insertará nombres de campo como [TABLE_NAME]![FIELD_NAME] . Esto no funcionará También Access permite nombres de campo no estándar que comienzan con un dígito como "10kmSq" y le permite usarlos en SQL como SELECT [10kmSq] FROM ... Esto tampoco funcionará. Si hay un error en la sintaxis de SQL, la variable de retorno contendrá un mensaje de error.

En segundo lugar, la cantidad de datos que puede devolver parece estar limitada a 64 Kb. Si intenta ejecutar SQL que devuelve demasiado, la sesión de 32 bits no finaliza y el script se cuelga.

Answer 3

No tuvo éxito con las respuestas dadas, pero aquí está el enfoque paso a paso que eventualmente hizo el truco para mí. Tener Windows 8 en 64 bits. Con 64 y 32 bit R instalados. Mi acceso es de 32 bits.

Pasos a seguir, asumiendo el acceso de 32 bits en Windows 8

1. Seleccione 32 bit R (es solo una configuración en el estudio R)
2. buscar en Windows para configurar orígenes de datos ODBC (32 bit)
3. Vaya a Sistema DSN> Agregar
4. Elija Driver do Microsoft Access (* .mdb)> Finalizar
5. Nombre de fuente de datos: ProjecnameAcc
6. Descripción: ProjectnameAcc
7. Asegúrese de seleccionar realmente la base de datos> Aceptar

Ahora podría ejecutar el código que me gusta

channel <- odbcConnect("ProjectnameAcc")
Table1Dat <- sqlFetch(channel, "Table1")

Answer 4

Usando consejos de otros, aquí hay un ejemplo explícito de cómo obtener datos de acceso de 32 bits en R de 64 bits que puede escribir en una secuencia de comandos para que no tenga que hacer los pasos manualmente. Para que esto se ejecute, debe tener disponible R de 32 bits, y este script asume una ubicación predeterminada para el R de 32 bits, de modo que ajuste según sea necesario.

La primera parte del código va a su secuencia de comandos principal, la segunda parte de código es todo el contenido de un pequeño archivo de secuencia de comandos R que crea y se llama desde la secuencia de comandos principal, esta combinación extrae y guarda y luego carga los datos de la base de datos de acceso sin tener que parar.

Aquí está el bit que va en mi script principal, este se ejecuta desde 64 bit R

##  Lots of script above here
## set the 32-bit script location
pathIn32BitRScript <- "C:/R_Code/GetAccessDbTables.R"
## run the 32 bit script
system(paste0(Sys.getenv("R_HOME"), "/bin/i386/Rscript.exe ",pathIn32BitRScript))
## Set the path for loading the rda files created from the little script 
pathOutUpAccdb <- "C/R_Work/"
## load the tables just created from that script
load(paste0(pathOutUpAccdb,"pots.rda"))
load(paste0(pathOutUpAccdb,"pans.rda"))
## Lots of script below here

Aquí está el bit que es el script separado llamado GetAccessTables.R

library(RODBC).    
## set the database path
inCopyDbPath <- "C:/Projects/MyDatabase.accdb"
## connect to the database
conAccdb <- odbcConnectAccess2007(inCopyDbPath) 

## Fetch the tables from the database. Modify the as-is and string settings as desired
pots <- sqlFetch (conAccdb,"tbl_Pots",as.is=FALSE, stringsAsFactors = FALSE)
pans <- sqlFetch(conAccdb,"tbl_Pans",as.is=FALSE, stringsAsFactors = FALSE)
## Save the tables
save(pots, file = "C/R_Work/pots.rda")
save(pans, file = "C:/R_Work/pans.rda")
close(conAccdb)

Answer 5

Use odbcDriverConnect en odbcDriverConnect lugar. Si tiene R de 64 bits instalado, puede que tenga que usar la compilación R de 32 bits.

odbcDriverConnect("Driver={Microsoft Access Driver (*.mdb, *.accdb)};DBQ=D:/SampleDB1/sampleDB1.mdb")