Sketch of safe-call-into-r

[westonpace]

I may have been a little optimistic. This approach should be able to work. However, we may have to expose C++'s async API to make it happen. The problem with using a sync call is...

Table ReadParquet() {
  Future<Table> table = ScheduleReadParquetTask();
  // At this point we are going to block the main R thread.  We don't want to do that.  We want
  // to re-use the main R thread for I/O tasks.  We can't call later::run_now because are not R-aware here
  // and we don't want to pepper the C++ code base with something like MAYBE_YIELD_TO_R
  return table.result();
  // By the time we return it is too late to call later::run_now.  Any child tasks needed to read the parquet
  // file (e.g. reading from a connection) must have completed by now.
}

When using an async call...

Future<Table> ReadParquet() {
  return ScheduleReadParquetTask();
  // At this point the work has started but not finished.  Once we return from this method we can
  // call later::run_now from an R context.
}

Also, I'm not using later::run_now because we have event loops in C++ already (SerialExecutor). But, you could definitely use later event loops if you wanted.

[github-actions]

Thanks for opening a pull request!

If this is not a minor PR. Could you open an issue for this pull request on JIRA? https://issues.apache.org/jira/browse/ARROW

Opening JIRAs ahead of time contributes to the Openness of the Apache Arrow project.

Then could you also rename pull request title in the following format?

ARROW-${JIRA_ID}: [${COMPONENT}] ${SUMMARY}

or

MINOR: [${COMPONENT}] ${SUMMARY}

See also:

• Other pull requests
• Contribution Guidelines - How to contribute patches