Support translations of simple data.table functions

[MichaelChirico]

Describe the bug, including details regarding any error messages, version, and platform.

Related: #39822.
Context: MichaelChirico/funchir#18

Goal: acero engine translates some {data.table} functions into {arrow} executions.

#39822 is much more ambitious since it requires implementing translation for the most complex part of the {data.table} API, namely [.

This request should be much simpler to satisfy -- at a minimum, translate fcase(), but we should also be able to do fifelse() and fcoalesce(). These have {dplyr} equivalents case_when(), if_else(), and coalesce(), respectively.

My assumption here is that acero works by static analysis -- read the AST, apply known translations, i.e. analogous to {dbplyr}. If there's something deeper going on then this is just a duplicate of #39822.

I can help prepare a PR but don't really have a machine suitable for that available until next year. Filing this issue first as a sanity check & to gauge interest.

Component(s)

R

[jonkeane]

My assumption here is that acero works by static analysis -- read the AST, apply known translations, i.e. analogous to {dbplyr}

Yup, at a high level this is what's going on. You might have already found these, but here are some pointers around case_when that might be helpful: we register the binding which does some validation and then uses arrow_eval each of the case formulas. This arrow_eval is to create arrow expressions (you might not need it if you're not operating on expressions that reference columns in a data.frame(-like) object. Then the arrow expression itself is returned](

arrow/r/R/dplyr-funcs-conditional.R

Lines 136 to 146 in 352b710

	Expression$create(
	"case_when",
	args = c(
	Expression$create(
	"make_struct",
	args = query,
	options = list(field_names = as.character(seq_along(query)))
	),
	value
	)
	)

). If fcase() don't need the tidy evaluation semantics for selecting columns, the binding might be as simple as just using a similar Expression$create() on the expressions themselves (there's probably a bit more to that, but much of the complication with the dplyr bindings is getting the tidy evaluation working).

The test for case_when use a helper that is called compare_dplyr_binding, which in this case is a little ill-named, but should work, so long as the input data.frame is .input in the test code.

All of that said, because we are looking through the AST to find bindings, if fcase had an AST that aws expressions that already had bindings (either base R or even a remap to case_when) in this circumstance, it should work with arrow without even needing any changes in the arrow package itself.

Something like the following should work:

fcase_arrow <- function(..., default = NA) {
  dots <- rlang::list2(...)
  # for each pair of arguments, make a formula expression
  formulae <- lapply(seq(1, length(dots), by = 2), function(i) rlang::expr(dots[[!!i]] ~ dots[[!!(i + 1)]]))
  dplyr::case_when(!!!formulae, .default = default)
}

You could build up the acero with Expression$create("case_when", ...) expressions rather than using rlang's expression and dots management there.