Support to specify 32-bit R

[jpshanno]

With RStudio's plans to drop support for 32-bit R, there are going to be a number of users who can't connect to existing datasets. To get around this problem I wrote a few functions to fetch sql queries with 32-bit Rscript and pass the data back to my active RStudio session. It would be nice if people in my situation, and the people in the thread above, could leverage callr to access their data. It wouldn't be a complete fix to the problem, since it would require a new connection to the data source each time callr is used, but I think it would help out in a lot of use cases. I'd be happy to contribute if this is something that moves forward.

[gaborcsardi]

Right now callr assumes that the two R versions are the same. Maybe this can be relaxed, and we can allow using 32/64 bit of the same R version, I'll need to check if the RDS files that are copied between the processes will still work.

[jpshanno]

So far I've had no problem with the RDS files working between the 32-bit and 64-bit, but I haven't been trying to break things or look for edge cases. Here's one of the functions I'm using that fetches a whole table from a MS Access database.

r32_fetch_table <- function(db.path,
                            table.name) {

  stopifnot(is.character(db.path),
            length(db.path) == 1)

  rscript32 <-
    file.path(R.home("bin/i386"),
              "Rscript")

  if(!any(grepl("Rscript",
               list.files(dirname(rscript32))))){
    stop('r32_fetch_table requires a 32-bit version of R to be installed with
         your default 64 bit R installation.')
  }

  temp_file <-
    normalizePath(file.path(tempdir(),
                            'data_file.rds'),
                  winslash = "/",
                  mustWork = FALSE)

  script <-
    glue::glue(
      "db <- DBI::dbConnect(odbc::odbc(),
                          Driver = 'Microsoft Access Driver (*.mdb, *.accdb)',
                          Dbq = '{db.path}')
      table <- DBI::dbReadTable(db,
                      '{table.name}')
      DBI::dbDisconnect(db)
      readr::write_rds(x = table,
                       path = '{temp_file}')")

  command <-
    glue::glue("{rscript32} -e \
                \"{script}\"")

  res <-
    system(command)

  if(res != 0){
    print(command)
    stop("The above system call failed with exit code ", res)
  }

  df <-
    readr::read_rds(temp_file)

  unlink(temp_file)

  return(df)
}

^{Created on 2019-01-15 by the reprex package (v0.2.1)}

[jimhester]

From Serialization-Formats in R-internals it looks to me like the Rds format is the same for 32 and 64 bit.

Atomic vector objects write their length followed by the data: generic vector-list objects write their length followed by a call to WriteItem for each element. The code for CHARSXPs special-cases NA_STRING and writes it as length -1 with no data. Lengths no more than 2^31 - 1 are written in that way and larger lengths (which only occur on 64-bit systems) as -1 followed by the upper and lower 32-bits as integers (regarded as unsigned).

So the only difference is with long vectors, which 32 bit R doesn't support anyway, so I think all 32bit -> 64bit serialization should work, though maybe not the other way around.

[gaborcsardi]

@jimhester thanks for looking into this, I think we can add it then.