Experimental lifecycle

Writes a data frame into a range of cells. Main differences from sheet_write() (a.k.a. write_sheet()):

  • Narrower scope. range_write() literally targets some cells, not a whole (work)sheet.

  • The edited rectangle is not explicitly styled as a table. Nothing special is done re: formatting a header row or freezing rows.

  • Column names can be suppressed. This means that, although data must be a data frame (at least for now), range_write() can actually be used to write arbitrary data.

  • The target (spread)Sheet and (work)sheet must already exist. There is no ability to create a Sheet or add a worksheet.

  • The target sheet dimensions are not "trimmed" to shrink-wrap the data. However, the sheet might gain rows and/or columns, in order to write data to the user-specified range.

If you just want to add rows to an existing table, the function you probably want is sheet_append().

range_write(
  ss,
  data,
  sheet = NULL,
  range = NULL,
  col_names = TRUE,
  reformat = TRUE
)

Arguments

ss

Something that identifies a Google Sheet: its file ID, a URL from which we can recover the ID, an instance of googlesheets4_spreadsheet (returned by gs4_get()), or a dribble, which is how googledrive represents Drive files. Processed through as_sheets_id().

data

A data frame.

sheet

Sheet to write into, in the sense of "worksheet" or "tab". You can identify a sheet by name, with a string, or by position, with a number. Ignored if the sheet is specified via range. If neither argument specifies the sheet, defaults to the first visible sheet.

range

Where to write. This range argument has important similarities and differences to range elsewhere (e.g. range_read()):

  • Similarities: Can be a cell range, using A1 notation ("A1:D3") or using the helpers in cell-specification. Can combine sheet name and cell range ("Sheet1!A5:A") or refer to a sheet by name (range = "Sheet1", although sheet = "Sheet1" is preferred for clarity).

  • Difference: Can NOT be a named range.

  • Difference: range can be interpreted as the start of the target rectangle (the upper left corner) or, more literally, as the actual target rectangle. See the "Range specification" section for details.

col_names

Logical, indicates whether to send the column names of data.

reformat

Logical, indicates whether to reformat the affected cells. Currently googlesheets4 provides no real support for formatting, so reformat = TRUE effectively means that edited cells become unformatted.

Value

The input ss, as an instance of sheets_id

Range specification

The range argument of range_write() is special, because the Sheets API can implement it in 2 different ways:

  • If range represents exactly 1 cell, like "B3", it is taken as the start (or upper left corner) of the targeted cell rectangle. The edited cells are determined implicitly by the extent of the data we are writing. This frees you from doing fiddly range computations based on the dimensions of the data.

  • If range describes a rectangle with multiple cells, it is interpreted as the actual rectangle to edit. It is possible to describe a rectangle that is unbounded on the right (e.g. "B2:4"), on the bottom (e.g. "A4:C"), or on both the right and the bottom (e.g. cell_limits(c(2, 3), c(NA, NA)). Note that all cells inside the rectangle receive updated data and format. Important implication: if the data object isn't big enough to fill the target rectangle, the cells that don't receive new data are effectively cleared, i.e. the existing value and format are deleted.

See also

Examples

if (gs4_has_token()) { # create a Sheet with some initial, empty (work)sheets (ss <- gs4_create("range-write-demo", sheets = c("alpha", "beta"))) df <- data.frame( x = 1:3, y = letters[1:3] ) # write df somewhere other than the "upper left corner" range_write(ss, data = df, range = "D6") # view your magnificent creation in the browser gs4_browse(ss) # send data of disparate types to a 1-row rectangle dat <- tibble::tibble( string = "string", logical = TRUE, datetime = Sys.time() ) range_write(ss, data = dat, sheet = "beta", col_names = FALSE) # send data of disparate types to a 1-column rectangle dat <- tibble::tibble( x = list(Sys.time(), FALSE, "string") ) range_write(ss, data = dat, range = "beta!C5", col_names = FALSE) # clean up googledrive::drive_find("range-write-demo") %>% googledrive::drive_trash() }
#> Creating new Sheet: "range-write-demo"
#> Editing "range-write-demo"
#> Writing to sheet "alpha"
#> Request failed [429]. Retry 1 happens in 100.9 seconds ...
#> Request failed [429]. Retry 2 happens in 2.3 seconds ...
#> Editing "range-write-demo"
#> Writing to sheet "beta"
#> Editing "range-write-demo"
#> Writing to sheet "beta"
#> Files trashed: #> * range-write-demo: 1LGEovxjG9ygu_Ram5VUDzUYYAUUwJFQHVTwpuWoeD64