rbindlist {data.table} | R Documentation

## Makes one data.table from a list of many

### Description

Same as `do.call("rbind", l)` on `data.frame`s, but much faster.

### Usage

    rbindlist(l, use.names="check", fill=FALSE, idcol=NULL)
    # rbind(\dots, use.names=TRUE, fill=FALSE, idcol=NULL)

### Arguments

`l` | A list containing `data.table`, `data.frame` or `list` objects. `...` is the same but you pass the objects by name separately.
`use.names` | `TRUE` binds by matching column name, `FALSE` by position. ‘check' (default) warns if all items don’t have the same names in the same order and then currently proceeds as if 'use.names=FALSE' for backwards compatibility (`TRUE` in future); see news for v1.12.2.
`fill` | `TRUE` fills missing columns with NAs. By default `FALSE`. When `TRUE`, `use.names` is set to `TRUE`.
`idcol` | Creates a column in the result showing which list item those rows came from. `TRUE` names this column `".id"`. `idcol="file"` names this column `"file"`. If the input list has names, those names are the values placed in this id column, otherwise the values are an integer vector `1:length(l)`. See `examples`.

### Details

Each item of `l` can be a `data.table`, `data.frame` or `list`, including `NULL` (skipped) or an empty object (0 rows). `rbindlist` is most useful when there are an unknown number of (potentially many) objects to stack, such as returned by `lapply(fileNames, fread)`. `rbind` is most useful to stack two or three objects which you know in advance. `...` should contain at least one `data.table` for `rbind(...)` to call the fast method and return a `data.table`, whereas `rbindlist(l)` always returns a `data.table` even when stacking a plain `list` with a `data.frame`, for example.

Columns with duplicate names are bound in the order of occurrence, similar to base. The position (column number) that each duplicate name occurs is also retained.

If column `i` does not have the same type in each of the list items; e.g, the column is `integer` in item 1 while others are `numeric`, they are coerced to the highest type.

If a column contains factors then a factor is created. If any of the factors are also ordered factors then the longest set of ordered levels are found (the first if this is tied). Then the ordered levels from each list item are checked to be an ordered subset of these longest levels. If any ambiguities are found (e.g. `blue<green` vs `green<blue`), or any ordered levels are missing from the longest, then a regular factor is created with warning. Any strings in regular factor and character columns which are missing from the longest ordered levels are added at the end.

### Value

An unkeyed `data.table` containing a concatenation of all the items passed in.

### See Also

`data.table`, `split.data.table`

### Examples

    # default case
    DT1 = data.table(A=1:3,B=letters[1:3])
    DT2 = data.table(A=4:5,B=letters[4:5])
    l = list(DT1,DT2)
    rbindlist(l)

    # bind correctly by names
    DT1 = data.table(A=1:3,B=letters[1:3])
    DT2 = data.table(B=letters[4:5],A=4:5)
    l = list(DT1,DT2)
    rbindlist(l, use.names=TRUE)

    # fill missing columns, and match by col names
    DT1 = data.table(A=1:3,B=letters[1:3])
    DT2 = data.table(B=letters[4:5],C=factor(1:2))
    l = list(DT1,DT2)
    rbindlist(l, use.names=TRUE, fill=TRUE)

    # generate index column, auto generates indices
    rbindlist(l, use.names=TRUE, fill=TRUE, idcol=TRUE)
    # let's name the list
    setattr(l, 'names', c("a", "b"))
    rbindlist(l, use.names=TRUE, fill=TRUE, idcol="ID")

[Package data.table version 1.12.2 Index]