API

# API for dplyr package

## Exported functions

add_op_single(name, .data, dots = list(), args = list())
add_rownames(df, var = "rowname")
all_equal(target, current, ignore_col_order = TRUE, ignore_row_order = TRUE, convert = FALSE, ...)
anti_join(x, y, by = NULL, copy = FALSE, ...)
arrange(.data, ...)
arrange_(.data, ..., .dots)
as.tbl(x, ...)
as.tbl_cube(x, ...)
auto_copy(x, y, copy = FALSE, ...)
bench_tbls(tbls, op, ..., times = 10)
between(x, left, right)
bind_cols(...)
bind_rows(..., .id = NULL)
build_sql(..., .env = parent.frame(), con = NULL)
case_when(...)
changes(x, y)
coalesce(x, ...)
collapse(x, ...)
collect(x, ...)
combine(...)
common_by(by = NULL, x, y)
compare_tbls(tbls, op, ref = NULL, compare = equal_data_frame, ...)
compute(x, name = random_table_name(), ...)
contains(match, ignore.case = TRUE, vars = current_vars())
copy_lahman(src, ...)
copy_nycflights13(src, ...)
copy_to(dest, df, name = deparse(substitute(df)), ...)
count(x, ..., wt = NULL, sort = FALSE)
count_(x, vars, wt = NULL, sort = FALSE)
cumall(x)
cumany(x)
cume_dist(x)
cummean(x)
current_vars()
db_analyze(con, table, ...)
db_begin(con, ...)
db_commit(con, ...)
db_create_index(con, table, columns, name = NULL, unique = FALSE, ...)
db_create_indexes(con, table, indexes = NULL, unique = FALSE, ...)
db_create_table(con, table, types, temporary = FALSE, ...)
db_data_type(con, fields)
db_drop_table(con, table, force = FALSE, ...)
db_explain(con, sql, ...)
db_has_table(con, table)
db_insert_into(con, table, values, ...)
db_list_tables(con)
db_query_fields(con, sql, ...)
db_query_rows(con, sql, ...)
db_rollback(con, ...)
db_save_query(con, sql, name, temporary = TRUE, ...)
dense_rank(x)
desc(x)
dim_desc(x)
distinct(.data, ..., .keep_all = FALSE)
distinct_(.data, ..., .dots, .keep_all = FALSE)
do(.data, ...)
do_(.data, ..., .dots)
ends_with(match, ignore.case = TRUE, vars = current_vars())
escape(x, parens = NA, collapse = " ", con = NULL)
eval_tbls(tbls, op)
everything(vars = current_vars())
explain(x, ...)
failwith(default = NULL, f, quiet = FALSE)
filter(.data, ...)
filter_(.data, ..., .dots)
first(x, order_by = NULL, default = default_missing(x))
full_join(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), ...)
funs(...)
funs_(dots, args = list(), env = baseenv())
group_by(.data, ..., add = FALSE)
group_by_(.data, ..., .dots, add = FALSE)
group_by_prepare(.data, ..., .dots, add = FALSE)
group_indices(.data, ...)
group_indices_(.data, ..., .dots)
group_size(x)
grouped_df(data, vars, drop = TRUE)
groups(x)
has_lahman(type, ...)
has_nycflights13(type = c("sqlite", "postgresql"), ...)
id(.variables, drop = FALSE)
ident(...)
if_else(condition, true, false, missing = NULL)
inner_join(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), ...)
intersect(x, y, ...)
is.grouped_df(x)
is.ident(x)
is.sql(x)
is.src(x)
is.tbl(x)
join_query(x, y, type = "inner", by = NULL, suffix = c(".x", ".y"))
lag(x, n = 1L, default = NA, order_by = NULL, ...)
lahman_df()
lahman_dt()
lahman_mysql(dbname = "lahman", ...)
lahman_postgres(dbname = "lahman", ...)
lahman_sqlite(path = NULL)
lahman_srcs(..., quiet = NULL)
last(x, order_by = NULL, default = default_missing(x))
lead(x, n = 1L, default = NA, order_by = NULL, ...)
left_join(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), ...)
location(df)
make_tbl(subclass, ...)
matches(match, ignore.case = TRUE, vars = current_vars())
memdb_frame(..., .name = random_table_name())
min_rank(x)
mutate(.data, ...)
mutate_(.data, ..., .dots)
mutate_all(.tbl, .funs, ...)
mutate_at(.tbl, .cols, .funs, ...)
mutate_each(tbl, funs, ...)
mutate_each_(tbl, funs, vars)
mutate_each_q(...)
mutate_if(.tbl, .predicate, .funs, ...)
n()
n_distinct(..., na.rm = FALSE)
n_groups(x)
na_if(x, y)
named_commas(...)
near(x, y, tol = .Machine$double.eps^0.5)
nth(x, n, order_by = NULL, default = default_missing(x))
ntile(x, n)
num_range(prefix, range, width = NULL, vars = current_vars())
nycflights13_postgres(dbname = "nycflights13", ...)
nycflights13_sqlite(path = NULL)
one_of(..., vars = current_vars())
op_base(name, src, x, vars)
op_double(name, x, y, args = list())
op_grps(op)
op_single(name, x, dots = list(), args = list())
op_sort(op)
op_vars(op)
order_by(order_by, call)
partial_eval(call, tbl = NULL, env = parent.frame())
percent_rank(x)
progress_estimated(n, min_time = 0)
query(con, sql, .vars)
rbind_all(x, id = NULL)
rbind_list(...)
recode(.x, ..., .default = NULL, .missing = NULL)
recode_factor(.x, ..., .default = NULL, .missing = NULL, .ordered = FALSE)
regroup(x, value)
rename(.data, ...)
rename_(.data, ..., .dots)
rename_vars(vars, ...)
rename_vars_(vars, args)
right_join(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), ...)
row_number(x)
rowwise(data)
same_src(x, y)
sample_frac(tbl, size = 1, replace = FALSE, weight = NULL, .env = parent.frame())
sample_n(tbl, size, replace = FALSE, weight = NULL, .env = parent.frame())
select(.data, ...)
select_(.data, ..., .dots)
select_if(.data, .predicate, ...)
select_query(from, select = sql("*"), where = character(), group_by = character(), having = character(), order_by = character(), limit = NULL, distinct = FALSE)
select_vars(vars, ..., include = character(), exclude = character())
select_vars_(vars, args, include = character(), exclude = character())
semi_join(x, y, by = NULL, copy = FALSE, ...)
semi_join_query(x, y, anti = FALSE, by = NULL)
set_op_query(x, y, type = type)
setdiff(x, y, ...)
setequal(x, y, ...)
show_query(x)
slice(.data, ...)
slice_(.data, ..., .dots)
sql(...)
sql_build(op, con, ...)
sql_escape_ident(con, x)
sql_escape_string(con, x)
sql_infix(f)
sql_join(con, x, y, type = "inner", by = NULL, ...)
sql_not_supported(f)
sql_prefix(f, n = NULL)
sql_quote(x, quote)
sql_render(query, con = NULL, ...)
sql_select(con, select, from, where = NULL, group_by = NULL, having = NULL, order_by = NULL, limit = NULL, distinct = FALSE, ...)
sql_semi_join(con, x, y, anti = FALSE, by = NULL, ...)
sql_set_op(con, x, y, method)
sql_subquery(con, from, name = random_table_name(), ...)
sql_translate_env(con)
sql_translator(..., .funs = list(), .parent = new.env(parent = emptyenv()))
sql_variant(scalar = sql_translator(), aggregate = sql_translator(), window = sql_translator())
sql_vector(x, parens = NA, collapse = " ", con = NULL)
src(subclass, ...)
src_desc(x)
src_df(pkg = NULL, env = NULL)
src_local(tbl, pkg = NULL, env = NULL)
src_memdb()
src_mysql(dbname, host = NULL, port = 0L, user = "root", password, ...)
src_postgres(dbname = NULL, host = NULL, port = NULL, user = NULL, password = NULL, ...)
src_sql(subclass, con, ...)
src_sqlite(path, create = FALSE)
src_tbls(x)
starts_with(match, ignore.case = TRUE, vars = current_vars())
summarise(.data, ...)
summarise_(.data, ..., .dots)
summarise_all(.tbl, .funs, ...)
summarise_at(.tbl, .cols, .funs, ...)
summarise_each(tbl, funs, ...)
summarise_each_(tbl, funs, vars)
summarise_each_q(...)
summarise_if(.tbl, .predicate, .funs, ...)
summarize(.data, ...)
summarize_(.data, ..., .dots)
summarize_all(.tbl, .funs, ...)
summarize_at(.tbl, .cols, .funs, ...)
summarize_each(tbl, funs, ...)
summarize_each_(tbl, funs, vars)
summarize_if(.tbl, .predicate, .funs, ...)
tally(x, wt, sort = FALSE)
tbl(src, ...)
tbl_cube(dimensions, measures)
tbl_df(data)
tbl_sql(subclass, src, from, ..., vars = attr(from, "vars"))
tbl_vars(x)
test_frame(..., srcs = test_srcs$get(), ignore = character())
test_load(df, name = random_table_name(), srcs = test_srcs$get(), ignore = character())
test_register_src(name, src)
top_n(x, n, wt)
translate_sql(..., con = NULL, vars = character(), vars_group = NULL, vars_order = NULL, window = TRUE)
translate_sql_(dots, con = NULL, vars = character(), vars_group = NULL, vars_order = NULL, window = TRUE)
transmute(.data, ...)
transmute_(.data, ..., .dots)
ungroup(x, ...)
union(x, y, ...)
union_all(x, y, ...)
vars(...)
with_order(order_by, fun, x, ...)

## S3 methods

anti_join.data.frame(x, y, by = NULL, copy = FALSE, ...)
anti_join.tbl_df(x, y, by = NULL, copy = FALSE, ...)
anti_join.tbl_lazy(x, y, by = NULL, copy = FALSE, auto_index = FALSE, ...)
arrange_.data.frame(.data, ..., .dots)
arrange_.tbl_df(.data, ..., .dots)
arrange_.tbl_lazy(.data, ..., .dots)
as.fun_list.character(.x, ..., .env = baseenv())
as.fun_list.fun_list(.x, ..., .env = baseenv())
as.fun_list.function(.x, ..., .env = baseenv())
as.tbl_cube.array(x, dim_names = names(dimnames(x)), met_name = deparse(substitute(x)), ...)
as.tbl_cube.data.frame(x, dim_names = NULL, met_name = guess_met(x), ...)
as.tbl_cube.matrix(x, dim_names = names(dimnames(x)), met_name = deparse(substitute(x)), ...)
as.tbl_cube.table(x, dim_names = names(dimnames(x)), met_name = "Freq", ...)
as.tbl.data.frame(x, ...)
as.tbl.tbl(x, ...)
auto_copy.tbl_cube(x, y, copy = FALSE, ...)
auto_copy.tbl_df(x, y, copy = FALSE, ...)
auto_copy.tbl_sql(x, y, copy = FALSE, ...)
collapse.data.frame(x, ...)
collapse.tbl_sql(x, vars = NULL, ...)
collect.data.frame(x, ...)
collect.tbl_sql(x, ..., n = 1e+05, warn_incomplete = TRUE)
compute.data.frame(x, ...)
compute.tbl_sql(x, name = random_table_name(), temporary = TRUE, unique_indexes = list(), indexes = list(), ...)
copy_to.src_local(dest, df, name = deparse(substitute(df)), ...)
copy_to.src_sql(dest, df, name = deparse(substitute(df)), types = NULL, temporary = TRUE, unique_indexes = NULL, indexes = NULL, analyze = TRUE, ...)
db_analyze.DBIConnection(con, table, ...)
db_analyze.MySQLConnection(con, table, ...)
db_begin.DBIConnection(con, ...)
db_begin.MySQLConnection(con, ...)
db_begin.PostgreSQLConnection(con, ...)
db_commit.DBIConnection(con, ...)
db_commit.MySQLConnection(con, ...)
db_create_index.DBIConnection(con, table, columns, name = NULL, unique = FALSE, ...)
db_create_index.MySQLConnection(con, table, columns, name = NULL, unique = FALSE, ...)
db_create_indexes.DBIConnection(con, table, indexes = NULL, unique = FALSE, ...)
db_create_table.DBIConnection(con, table, types, temporary = FALSE, ...)
db_data_type.DBIConnection(con, fields)
db_data_type.MySQLConnection(con, fields, ...)
db_drop_table.DBIConnection(con, table, force = FALSE, ...)
db_explain.DBIConnection(con, sql, ...)
db_explain.PostgreSQLConnection(con, sql, format = "text", ...)
db_has_table.DBIConnection(con, table)
db_has_table.MySQLConnection(con, table, ...)
db_has_table.PostgreSQLConnection(con, table, ...)
db_insert_into.MySQLConnection(con, table, values, ...)
db_insert_into.PostgreSQLConnection(con, table, values, ...)
db_insert_into.SQLiteConnection(con, table, values, ...)
db_list_tables.DBIConnection(con)
db_query_fields.DBIConnection(con, sql, ...)
db_query_fields.DBITestConnection(con, sql, ...)
db_query_fields.PostgreSQLConnection(con, sql, ...)
db_query_rows.DBIConnection(con, sql, ...)
db_rollback.DBIConnection(con, ...)
db_save_query.DBIConnection(con, sql, name, temporary = TRUE, ...)
distinct_.data.frame(.data, ..., .dots, .keep_all = FALSE)
distinct_.grouped_df(.data, ..., .dots, .keep_all = FALSE)
distinct_.tbl_df(.data, ..., .dots)
distinct_.tbl_lazy(.data, ..., .dots, .keep_all = FALSE)
do_.data.frame(.data, ..., .dots)
do_.grouped_df(.data, ..., env = parent.frame(), .dots)
do_.NULL(.data, ..., .dots)
do_.rowwise_df(.data, ..., .dots)
do_.tbl_sql(.data, ..., .dots, .chunk_size = 10000L)
escape.character(x, parens = NA, collapse = ", ", con = NULL)
escape.Date(x, parens = NA, collapse = ", ", con = NULL)
escape.double(x, parens = NA, collapse = ", ", con = NULL)
escape.factor(x, parens = NA, collapse = ", ", con = NULL)
escape.ident(x, parens = FALSE, collapse = ", ", con = NULL)
escape.integer(x, parens = NA, collapse = ", ", con = NULL)
escape.list(x, parens = TRUE, collapse = ", ", con = NULL)
escape.logical(x, parens = NA, collapse = ", ", con = NULL)
escape.NULL(x, parens = NA, collapse = " ", con = NULL)
escape.POSIXt(x, parens = NA, collapse = ", ", con = NULL)
escape.sql(x, parens = NULL, collapse = NULL, con = NULL)
explain.tbl_sql(x, ...)
filter_.data.frame(.data, ..., .dots)
filter_.tbl_cube(.data, ..., .dots)
filter_.tbl_df(.data, ..., .dots)
filter_.tbl_lazy(.data, ..., .dots)
full_join.data.frame(x, y, by = NULL, copy = FALSE, ...)
full_join.tbl_df(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), ...)
full_join.tbl_lazy(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), auto_index = FALSE, ...)
group_by_.data.frame(.data, ..., .dots, add = FALSE)
group_by_.rowwise_df(.data, ..., .dots, add = FALSE)
group_by_.tbl_cube(.data, ..., .dots, add = FALSE)
group_by_.tbl_lazy(.data, ..., .dots, add = TRUE)
group_indices_.data.frame(.data, ..., .dots)
group_indices_.grouped_df(.data, ..., .dots)
group_size.data.frame(x)
group_size.grouped_df(x)
group_size.rowwise_df(x)
group_size.tbl_sql(x)
groups.data.frame(x)
groups.grouped_df(x)
groups.tbl_cube(x)
groups.tbl_lazy(x)
inner_join.data.frame(x, y, by = NULL, copy = FALSE, ...)
inner_join.tbl_df(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), ...)
inner_join.tbl_lazy(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), auto_index = FALSE, ...)
intersect.data.frame(x, y, ...)
intersect.default(x, y, ...)
intersect.tbl_lazy(x, y, copy = FALSE, ...)
left_join.data.frame(x, y, by = NULL, copy = FALSE, ...)
left_join.tbl_df(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), ...)
left_join.tbl_lazy(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), auto_index = FALSE, ...)
mutate_.data.frame(.data, ..., .dots)
mutate_.tbl_df(.data, ..., .dots)
mutate_.tbl_lazy(.data, ..., .dots)
n_groups.data.frame(x)
n_groups.grouped_df(x)
n_groups.rowwise_df(x)
n_groups.tbl_sql(x)
op_grps.op_base(op)
op_grps.op_double(op)
op_grps.op_group_by(op)
op_grps.op_single(op)
op_grps.op_summarise(op)
op_grps.op_ungroup(op)
op_grps.tbl_lazy(op)
op_sort.op_arrange(op)
op_sort.op_base(op)
op_sort.op_double(op)
op_sort.op_single(op)
op_sort.op_summarise(op)
op_sort.tbl_lazy(op)
op_vars.op_base(op)
op_vars.op_join(op)
op_vars.op_mutate(op)
op_vars.op_rename(op)
op_vars.op_select(op)
op_vars.op_semi_join(op)
op_vars.op_set_op(op)
op_vars.op_single(op)
op_vars.op_summarise(op)
op_vars.tbl_lazy(op)
query.DBIConnection(con, sql, .vars)
recode.character(.x, ..., .default = NULL, .missing = NULL)
recode.factor(.x, ..., .default = NULL, .missing = NULL)
recode.numeric(.x, ..., .default = NULL, .missing = NULL)
rename_.data.frame(.data, ..., .dots)
rename_.grouped_df(.data, ..., .dots)
rename_.tbl_cube(.data, ..., .dots)
rename_.tbl_lazy(.data, ..., .dots)
right_join.data.frame(x, y, by = NULL, copy = FALSE, ...)
right_join.tbl_df(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), ...)
right_join.tbl_lazy(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), auto_index = FALSE, ...)
same_src.data.frame(x, y)
same_src.src_sql(x, y)
same_src.tbl_cube(x, y)
same_src.tbl_lazy(x, y)
same_src.tbl_sql(x, y)
sample_frac.data.frame(tbl, size = 1, replace = FALSE, weight = NULL, .env = parent.frame())
sample_frac.default(tbl, size = 1, replace = FALSE, weight = NULL, .env = parent.frame())
sample_frac.grouped_df(tbl, size = 1, replace = FALSE, weight = NULL, .env = parent.frame())
sample_n.data.frame(tbl, size, replace = FALSE, weight = NULL, .env = parent.frame())
sample_n.default(tbl, size, replace = FALSE, weight = NULL, .env = parent.frame())
sample_n.grouped_df(tbl, size, replace = FALSE, weight = NULL, .env = parent.frame())
select_.data.frame(.data, ..., .dots)
select_.grouped_df(.data, ..., .dots)
select_.tbl_cube(.data, ..., .dots)
select_.tbl_lazy(.data, ..., .dots)
semi_join.data.frame(x, y, by = NULL, copy = FALSE, ...)
semi_join.tbl_df(x, y, by = NULL, copy = FALSE, ...)
semi_join.tbl_lazy(x, y, by = NULL, copy = FALSE, auto_index = FALSE, ...)
setdiff.data.frame(x, y, ...)
setdiff.default(x, y, ...)
setdiff.tbl_lazy(x, y, copy = FALSE, ...)
setequal.data.frame(x, y, ...)
setequal.default(x, y, ...)
slice_.data.frame(.data, ..., .dots)
slice_.tbl_df(.data, ..., .dots)
sql_build.op_arrange(op, con, ...)
sql_build.op_base_local(op, con, ...)
sql_build.op_base_remote(op, con, ...)
sql_build.op_distinct(op, con, ...)
sql_build.op_filter(op, con, ...)
sql_build.op_group_by(op, con, ...)
sql_build.op_head(op, con, ...)
sql_build.op_join(op, con, ...)
sql_build.op_mutate(op, con, ...)
sql_build.op_rename(op, con, ...)
sql_build.op_select(op, con, ...)
sql_build.op_semi_join(op, con, ...)
sql_build.op_set_op(op, con, ...)
sql_build.op_summarise(op, con, ...)
sql_build.op_ungroup(op, con, ...)
sql_build.tbl_lazy(op, con = NULL, ...)
sql_build.tbl_sql(op, con, ...)
sql_escape_ident.DBITestConnection(con, x)
sql_escape_ident.default(con, x)
sql_escape_ident.MySQLConnection(con, x)
sql_escape_ident.SQLiteConnection(con, x)
sql_escape_string.default(con, x)
sql_join.default(con, x, y, type = "inner", by = NULL, ...)
sql_render.ident(query, con = NULL, ..., root = TRUE)
sql_render.join_query(query, con = NULL, ..., root = FALSE)
sql_render.op(query, con = NULL, ...)
sql_render.select_query(query, con = NULL, ..., root = FALSE)
sql_render.semi_join_query(query, con = NULL, ..., root = FALSE)
sql_render.set_op_query(query, con = NULL, ..., root = FALSE)
sql_render.sql(query, con = NULL, ...)
sql_render.tbl_lazy(query, con = NULL, ...)
sql_render.tbl_sql(query, con = NULL, ...)
sql_select.default(con, select, from, where = NULL, group_by = NULL, having = NULL, order_by = NULL, limit = NULL, distinct = FALSE, ...)
sql_semi_join.default(con, x, y, anti = FALSE, by = NULL, ...)
sql_set_op.default(con, x, y, method)
sql_subquery.default(con, from, name = unique_name(), ...)
sql_subquery.SQLiteConnection(con, from, name = unique_name(), ...)
sql_translate_env.DBITestConnection(con)
sql_translate_env.MySQLConnection(con)
sql_translate_env.NULL(con)
sql_translate_env.PostgreSQLConnection(con)
sql_translate_env.SQLiteConnection(con)
src_desc.src_mysql(x)
src_desc.src_postgres(x)
src_desc.src_sqlite(x)
src_tbls.src_local(x, ...)
src_tbls.src_sql(x, ...)
summarise_.data.frame(.data, ..., .dots)
summarise_.tbl_cube(.data, ..., .dots)
summarise_.tbl_df(.data, ..., .dots)
summarise_.tbl_lazy(.data, ..., .dots)
tbl_vars.data.frame(x)
tbl_vars.tbl_cube(x)
tbl_vars.tbl_lazy(x)
tbl.src_local(src, from, ...)
tbl.src_mysql(src, from, ...)
tbl.src_postgres(src, from, ...)
tbl.src_sqlite(src, from, ...)
transmute_.default(.data, ..., .dots)
ungroup.data.frame(x, ...)
ungroup.grouped_df(x, ...)
ungroup.rowwise_df(x, ...)
ungroup.tbl_lazy(x, ...)
union_all.data.frame(x, y, ...)
union_all.default(x, y, ...)
union_all.tbl_lazy(x, y, copy = FALSE, ...)
union.data.frame(x, y, ...)
union.default(x, y, ...)
union.tbl_lazy(x, y, copy = FALSE, ...)

## Exported data

base_agg: environment (environment[7])
base_no_win: environment (environment[22])
base_scalar: environment (environment[64])
base_win: environment (environment[22])