From 4cf58dbcb46e938ac913c01c232159c29a0da816 Mon Sep 17 00:00:00 2001
From: Neal Richardson <neal.p.richardson@gmail.com>
Date: Fri, 15 Jan 2021 14:04:30 -0800
Subject: [PATCH 1/4] Don't rewrite arrowExports unless there are changes

---
 r/R/arrowExports.R   | 795 ++++++++++++++++++++++---------------------
 r/data-raw/codegen.R |  36 +-
 2 files changed, 422 insertions(+), 409 deletions(-)

diff --git a/r/R/arrowExports.R b/r/R/arrowExports.R
index 9b2a1eeb42c..ea31eb0fdc5 100644
--- a/r/R/arrowExports.R
+++ b/r/R/arrowExports.R
@@ -1,1591 +1,1592 @@
 # Generated by using data-raw/codegen.R -> do not edit by hand
 
 Array__Slice1 <- function(array, offset){
-    .Call(`_arrow_Array__Slice1` , array, offset)
+    .Call(`_arrow_Array__Slice1`, array, offset)
 }
 
 Array__Slice2 <- function(array, offset, length){
-    .Call(`_arrow_Array__Slice2` , array, offset, length)
+    .Call(`_arrow_Array__Slice2`, array, offset, length)
 }
 
 Array__IsNull <- function(x, i){
-    .Call(`_arrow_Array__IsNull` , x, i)
+    .Call(`_arrow_Array__IsNull`, x, i)
 }
 
 Array__IsValid <- function(x, i){
-    .Call(`_arrow_Array__IsValid` , x, i)
+    .Call(`_arrow_Array__IsValid`, x, i)
 }
 
 Array__length <- function(x){
-    .Call(`_arrow_Array__length` , x)
+    .Call(`_arrow_Array__length`, x)
 }
 
 Array__offset <- function(x){
-    .Call(`_arrow_Array__offset` , x)
+    .Call(`_arrow_Array__offset`, x)
 }
 
 Array__null_count <- function(x){
-    .Call(`_arrow_Array__null_count` , x)
+    .Call(`_arrow_Array__null_count`, x)
 }
 
 Array__type <- function(x){
-    .Call(`_arrow_Array__type` , x)
+    .Call(`_arrow_Array__type`, x)
 }
 
 Array__ToString <- function(x){
-    .Call(`_arrow_Array__ToString` , x)
+    .Call(`_arrow_Array__ToString`, x)
 }
 
 Array__type_id <- function(x){
-    .Call(`_arrow_Array__type_id` , x)
+    .Call(`_arrow_Array__type_id`, x)
 }
 
 Array__Equals <- function(lhs, rhs){
-    .Call(`_arrow_Array__Equals` , lhs, rhs)
+    .Call(`_arrow_Array__Equals`, lhs, rhs)
 }
 
 Array__ApproxEquals <- function(lhs, rhs){
-    .Call(`_arrow_Array__ApproxEquals` , lhs, rhs)
+    .Call(`_arrow_Array__ApproxEquals`, lhs, rhs)
 }
 
 Array__data <- function(array){
-    .Call(`_arrow_Array__data` , array)
+    .Call(`_arrow_Array__data`, array)
 }
 
 Array__RangeEquals <- function(self, other, start_idx, end_idx, other_start_idx){
-    .Call(`_arrow_Array__RangeEquals` , self, other, start_idx, end_idx, other_start_idx)
+    .Call(`_arrow_Array__RangeEquals`, self, other, start_idx, end_idx, other_start_idx)
 }
 
 Array__View <- function(array, type){
-    .Call(`_arrow_Array__View` , array, type)
+    .Call(`_arrow_Array__View`, array, type)
 }
 
 Array__Validate <- function(array){
-    invisible(.Call(`_arrow_Array__Validate` , array))
+    invisible(.Call(`_arrow_Array__Validate`, array))
 }
 
 DictionaryArray__indices <- function(array){
-    .Call(`_arrow_DictionaryArray__indices` , array)
+    .Call(`_arrow_DictionaryArray__indices`, array)
 }
 
 DictionaryArray__dictionary <- function(array){
-    .Call(`_arrow_DictionaryArray__dictionary` , array)
+    .Call(`_arrow_DictionaryArray__dictionary`, array)
 }
 
 StructArray__field <- function(array, i){
-    .Call(`_arrow_StructArray__field` , array, i)
+    .Call(`_arrow_StructArray__field`, array, i)
 }
 
 StructArray__GetFieldByName <- function(array, name){
-    .Call(`_arrow_StructArray__GetFieldByName` , array, name)
+    .Call(`_arrow_StructArray__GetFieldByName`, array, name)
 }
 
 StructArray__Flatten <- function(array){
-    .Call(`_arrow_StructArray__Flatten` , array)
+    .Call(`_arrow_StructArray__Flatten`, array)
 }
 
 ListArray__value_type <- function(array){
-    .Call(`_arrow_ListArray__value_type` , array)
+    .Call(`_arrow_ListArray__value_type`, array)
 }
 
 LargeListArray__value_type <- function(array){
-    .Call(`_arrow_LargeListArray__value_type` , array)
+    .Call(`_arrow_LargeListArray__value_type`, array)
 }
 
 ListArray__values <- function(array){
-    .Call(`_arrow_ListArray__values` , array)
+    .Call(`_arrow_ListArray__values`, array)
 }
 
 LargeListArray__values <- function(array){
-    .Call(`_arrow_LargeListArray__values` , array)
+    .Call(`_arrow_LargeListArray__values`, array)
 }
 
 ListArray__value_length <- function(array, i){
-    .Call(`_arrow_ListArray__value_length` , array, i)
+    .Call(`_arrow_ListArray__value_length`, array, i)
 }
 
 LargeListArray__value_length <- function(array, i){
-    .Call(`_arrow_LargeListArray__value_length` , array, i)
+    .Call(`_arrow_LargeListArray__value_length`, array, i)
 }
 
 FixedSizeListArray__value_length <- function(array, i){
-    .Call(`_arrow_FixedSizeListArray__value_length` , array, i)
+    .Call(`_arrow_FixedSizeListArray__value_length`, array, i)
 }
 
 ListArray__value_offset <- function(array, i){
-    .Call(`_arrow_ListArray__value_offset` , array, i)
+    .Call(`_arrow_ListArray__value_offset`, array, i)
 }
 
 LargeListArray__value_offset <- function(array, i){
-    .Call(`_arrow_LargeListArray__value_offset` , array, i)
+    .Call(`_arrow_LargeListArray__value_offset`, array, i)
 }
 
 FixedSizeListArray__value_offset <- function(array, i){
-    .Call(`_arrow_FixedSizeListArray__value_offset` , array, i)
+    .Call(`_arrow_FixedSizeListArray__value_offset`, array, i)
 }
 
 ListArray__raw_value_offsets <- function(array){
-    .Call(`_arrow_ListArray__raw_value_offsets` , array)
+    .Call(`_arrow_ListArray__raw_value_offsets`, array)
 }
 
 LargeListArray__raw_value_offsets <- function(array){
-    .Call(`_arrow_LargeListArray__raw_value_offsets` , array)
+    .Call(`_arrow_LargeListArray__raw_value_offsets`, array)
 }
 
 Array__infer_type <- function(x){
-    .Call(`_arrow_Array__infer_type` , x)
+    .Call(`_arrow_Array__infer_type`, x)
 }
 
 Array__from_vector <- function(x, s_type){
-    .Call(`_arrow_Array__from_vector` , x, s_type)
+    .Call(`_arrow_Array__from_vector`, x, s_type)
 }
 
 ChunkedArray__from_list <- function(chunks, s_type){
-    .Call(`_arrow_ChunkedArray__from_list` , chunks, s_type)
+    .Call(`_arrow_ChunkedArray__from_list`, chunks, s_type)
 }
 
 DictionaryArray__FromArrays <- function(type, indices, dict){
-    .Call(`_arrow_DictionaryArray__FromArrays` , type, indices, dict)
+    .Call(`_arrow_DictionaryArray__FromArrays`, type, indices, dict)
 }
 
 Array__as_vector <- function(array){
-    .Call(`_arrow_Array__as_vector` , array)
+    .Call(`_arrow_Array__as_vector`, array)
 }
 
 ChunkedArray__as_vector <- function(chunked_array){
-    .Call(`_arrow_ChunkedArray__as_vector` , chunked_array)
+    .Call(`_arrow_ChunkedArray__as_vector`, chunked_array)
 }
 
 RecordBatch__to_dataframe <- function(batch, use_threads){
-    .Call(`_arrow_RecordBatch__to_dataframe` , batch, use_threads)
+    .Call(`_arrow_RecordBatch__to_dataframe`, batch, use_threads)
 }
 
 Table__to_dataframe <- function(table, use_threads){
-    .Call(`_arrow_Table__to_dataframe` , table, use_threads)
+    .Call(`_arrow_Table__to_dataframe`, table, use_threads)
 }
 
 ArrayData__get_type <- function(x){
-    .Call(`_arrow_ArrayData__get_type` , x)
+    .Call(`_arrow_ArrayData__get_type`, x)
 }
 
 ArrayData__get_length <- function(x){
-    .Call(`_arrow_ArrayData__get_length` , x)
+    .Call(`_arrow_ArrayData__get_length`, x)
 }
 
 ArrayData__get_null_count <- function(x){
-    .Call(`_arrow_ArrayData__get_null_count` , x)
+    .Call(`_arrow_ArrayData__get_null_count`, x)
 }
 
 ArrayData__get_offset <- function(x){
-    .Call(`_arrow_ArrayData__get_offset` , x)
+    .Call(`_arrow_ArrayData__get_offset`, x)
 }
 
 ArrayData__buffers <- function(x){
-    .Call(`_arrow_ArrayData__buffers` , x)
+    .Call(`_arrow_ArrayData__buffers`, x)
 }
 
 Buffer__is_mutable <- function(buffer){
-    .Call(`_arrow_Buffer__is_mutable` , buffer)
+    .Call(`_arrow_Buffer__is_mutable`, buffer)
 }
 
 Buffer__ZeroPadding <- function(buffer){
-    invisible(.Call(`_arrow_Buffer__ZeroPadding` , buffer))
+    invisible(.Call(`_arrow_Buffer__ZeroPadding`, buffer))
 }
 
 Buffer__capacity <- function(buffer){
-    .Call(`_arrow_Buffer__capacity` , buffer)
+    .Call(`_arrow_Buffer__capacity`, buffer)
 }
 
 Buffer__size <- function(buffer){
-    .Call(`_arrow_Buffer__size` , buffer)
+    .Call(`_arrow_Buffer__size`, buffer)
 }
 
 r___RBuffer__initialize <- function(x){
-    .Call(`_arrow_r___RBuffer__initialize` , x)
+    .Call(`_arrow_r___RBuffer__initialize`, x)
 }
 
 Buffer__data <- function(buffer){
-    .Call(`_arrow_Buffer__data` , buffer)
+    .Call(`_arrow_Buffer__data`, buffer)
 }
 
 Buffer__Equals <- function(x, y){
-    .Call(`_arrow_Buffer__Equals` , x, y)
+    .Call(`_arrow_Buffer__Equals`, x, y)
 }
 
 ChunkedArray__length <- function(chunked_array){
-    .Call(`_arrow_ChunkedArray__length` , chunked_array)
+    .Call(`_arrow_ChunkedArray__length`, chunked_array)
 }
 
 ChunkedArray__null_count <- function(chunked_array){
-    .Call(`_arrow_ChunkedArray__null_count` , chunked_array)
+    .Call(`_arrow_ChunkedArray__null_count`, chunked_array)
 }
 
 ChunkedArray__num_chunks <- function(chunked_array){
-    .Call(`_arrow_ChunkedArray__num_chunks` , chunked_array)
+    .Call(`_arrow_ChunkedArray__num_chunks`, chunked_array)
 }
 
 ChunkedArray__chunk <- function(chunked_array, i){
-    .Call(`_arrow_ChunkedArray__chunk` , chunked_array, i)
+    .Call(`_arrow_ChunkedArray__chunk`, chunked_array, i)
 }
 
 ChunkedArray__chunks <- function(chunked_array){
-    .Call(`_arrow_ChunkedArray__chunks` , chunked_array)
+    .Call(`_arrow_ChunkedArray__chunks`, chunked_array)
 }
 
 ChunkedArray__type <- function(chunked_array){
-    .Call(`_arrow_ChunkedArray__type` , chunked_array)
+    .Call(`_arrow_ChunkedArray__type`, chunked_array)
 }
 
 ChunkedArray__Slice1 <- function(chunked_array, offset){
-    .Call(`_arrow_ChunkedArray__Slice1` , chunked_array, offset)
+    .Call(`_arrow_ChunkedArray__Slice1`, chunked_array, offset)
 }
 
 ChunkedArray__Slice2 <- function(chunked_array, offset, length){
-    .Call(`_arrow_ChunkedArray__Slice2` , chunked_array, offset, length)
+    .Call(`_arrow_ChunkedArray__Slice2`, chunked_array, offset, length)
 }
 
 ChunkedArray__View <- function(array, type){
-    .Call(`_arrow_ChunkedArray__View` , array, type)
+    .Call(`_arrow_ChunkedArray__View`, array, type)
 }
 
 ChunkedArray__Validate <- function(chunked_array){
-    invisible(.Call(`_arrow_ChunkedArray__Validate` , chunked_array))
+    invisible(.Call(`_arrow_ChunkedArray__Validate`, chunked_array))
 }
 
 ChunkedArray__Equals <- function(x, y){
-    .Call(`_arrow_ChunkedArray__Equals` , x, y)
+    .Call(`_arrow_ChunkedArray__Equals`, x, y)
 }
 
 ChunkedArray__ToString <- function(x){
-    .Call(`_arrow_ChunkedArray__ToString` , x)
+    .Call(`_arrow_ChunkedArray__ToString`, x)
 }
 
 util___Codec__Create <- function(codec, compression_level){
-    .Call(`_arrow_util___Codec__Create` , codec, compression_level)
+    .Call(`_arrow_util___Codec__Create`, codec, compression_level)
 }
 
 util___Codec__name <- function(codec){
-    .Call(`_arrow_util___Codec__name` , codec)
+    .Call(`_arrow_util___Codec__name`, codec)
 }
 
 util___Codec__IsAvailable <- function(codec){
-    .Call(`_arrow_util___Codec__IsAvailable` , codec)
+    .Call(`_arrow_util___Codec__IsAvailable`, codec)
 }
 
 io___CompressedOutputStream__Make <- function(codec, raw){
-    .Call(`_arrow_io___CompressedOutputStream__Make` , codec, raw)
+    .Call(`_arrow_io___CompressedOutputStream__Make`, codec, raw)
 }
 
 io___CompressedInputStream__Make <- function(codec, raw){
-    .Call(`_arrow_io___CompressedInputStream__Make` , codec, raw)
+    .Call(`_arrow_io___CompressedInputStream__Make`, codec, raw)
 }
 
 compute___CastOptions__initialize <- function(allow_int_overflow, allow_time_truncate, allow_float_truncate){
-    .Call(`_arrow_compute___CastOptions__initialize` , allow_int_overflow, allow_time_truncate, allow_float_truncate)
+    .Call(`_arrow_compute___CastOptions__initialize`, allow_int_overflow, allow_time_truncate, allow_float_truncate)
 }
 
 Array__cast <- function(array, target_type, options){
-    .Call(`_arrow_Array__cast` , array, target_type, options)
+    .Call(`_arrow_Array__cast`, array, target_type, options)
 }
 
 ChunkedArray__cast <- function(chunked_array, target_type, options){
-    .Call(`_arrow_ChunkedArray__cast` , chunked_array, target_type, options)
+    .Call(`_arrow_ChunkedArray__cast`, chunked_array, target_type, options)
 }
 
 RecordBatch__cast <- function(batch, schema, options){
-    .Call(`_arrow_RecordBatch__cast` , batch, schema, options)
+    .Call(`_arrow_RecordBatch__cast`, batch, schema, options)
 }
 
 Table__cast <- function(table, schema, options){
-    .Call(`_arrow_Table__cast` , table, schema, options)
+    .Call(`_arrow_Table__cast`, table, schema, options)
 }
 
 compute__CallFunction <- function(func_name, args, options){
-    .Call(`_arrow_compute__CallFunction` , func_name, args, options)
+    .Call(`_arrow_compute__CallFunction`, func_name, args, options)
 }
 
 csv___ReadOptions__initialize <- function(options){
-    .Call(`_arrow_csv___ReadOptions__initialize` , options)
+    .Call(`_arrow_csv___ReadOptions__initialize`, options)
 }
 
 csv___ParseOptions__initialize <- function(options){
-    .Call(`_arrow_csv___ParseOptions__initialize` , options)
+    .Call(`_arrow_csv___ParseOptions__initialize`, options)
 }
 
 csv___ReadOptions__column_names <- function(options){
-    .Call(`_arrow_csv___ReadOptions__column_names` , options)
+    .Call(`_arrow_csv___ReadOptions__column_names`, options)
 }
 
 csv___ConvertOptions__initialize <- function(options){
-    .Call(`_arrow_csv___ConvertOptions__initialize` , options)
+    .Call(`_arrow_csv___ConvertOptions__initialize`, options)
 }
 
 csv___TableReader__Make <- function(input, read_options, parse_options, convert_options){
-    .Call(`_arrow_csv___TableReader__Make` , input, read_options, parse_options, convert_options)
+    .Call(`_arrow_csv___TableReader__Make`, input, read_options, parse_options, convert_options)
 }
 
 csv___TableReader__Read <- function(table_reader){
-    .Call(`_arrow_csv___TableReader__Read` , table_reader)
+    .Call(`_arrow_csv___TableReader__Read`, table_reader)
 }
 
 TimestampParser__kind <- function(parser){
-    .Call(`_arrow_TimestampParser__kind` , parser)
+    .Call(`_arrow_TimestampParser__kind`, parser)
 }
 
 TimestampParser__format <- function(parser){
-    .Call(`_arrow_TimestampParser__format` , parser)
+    .Call(`_arrow_TimestampParser__format`, parser)
 }
 
 TimestampParser__MakeStrptime <- function(format){
-    .Call(`_arrow_TimestampParser__MakeStrptime` , format)
+    .Call(`_arrow_TimestampParser__MakeStrptime`, format)
 }
 
 TimestampParser__MakeISO8601 <- function(){
-    .Call(`_arrow_TimestampParser__MakeISO8601` )
+    .Call(`_arrow_TimestampParser__MakeISO8601`)
 }
 
 dataset___Dataset__NewScan <- function(ds){
-    .Call(`_arrow_dataset___Dataset__NewScan` , ds)
+    .Call(`_arrow_dataset___Dataset__NewScan`, ds)
 }
 
 dataset___Dataset__schema <- function(dataset){
-    .Call(`_arrow_dataset___Dataset__schema` , dataset)
+    .Call(`_arrow_dataset___Dataset__schema`, dataset)
 }
 
 dataset___Dataset__type_name <- function(dataset){
-    .Call(`_arrow_dataset___Dataset__type_name` , dataset)
+    .Call(`_arrow_dataset___Dataset__type_name`, dataset)
 }
 
 dataset___Dataset__ReplaceSchema <- function(dataset, schm){
-    .Call(`_arrow_dataset___Dataset__ReplaceSchema` , dataset, schm)
+    .Call(`_arrow_dataset___Dataset__ReplaceSchema`, dataset, schm)
 }
 
 dataset___UnionDataset__create <- function(datasets, schm){
-    .Call(`_arrow_dataset___UnionDataset__create` , datasets, schm)
+    .Call(`_arrow_dataset___UnionDataset__create`, datasets, schm)
 }
 
 dataset___InMemoryDataset__create <- function(table){
-    .Call(`_arrow_dataset___InMemoryDataset__create` , table)
+    .Call(`_arrow_dataset___InMemoryDataset__create`, table)
 }
 
 dataset___UnionDataset__children <- function(ds){
-    .Call(`_arrow_dataset___UnionDataset__children` , ds)
+    .Call(`_arrow_dataset___UnionDataset__children`, ds)
 }
 
 dataset___FileSystemDataset__format <- function(dataset){
-    .Call(`_arrow_dataset___FileSystemDataset__format` , dataset)
+    .Call(`_arrow_dataset___FileSystemDataset__format`, dataset)
 }
 
 dataset___FileSystemDataset__filesystem <- function(dataset){
-    .Call(`_arrow_dataset___FileSystemDataset__filesystem` , dataset)
+    .Call(`_arrow_dataset___FileSystemDataset__filesystem`, dataset)
 }
 
 dataset___FileSystemDataset__files <- function(dataset){
-    .Call(`_arrow_dataset___FileSystemDataset__files` , dataset)
+    .Call(`_arrow_dataset___FileSystemDataset__files`, dataset)
 }
 
 dataset___DatasetFactory__Finish1 <- function(factory, unify_schemas){
-    .Call(`_arrow_dataset___DatasetFactory__Finish1` , factory, unify_schemas)
+    .Call(`_arrow_dataset___DatasetFactory__Finish1`, factory, unify_schemas)
 }
 
 dataset___DatasetFactory__Finish2 <- function(factory, schema){
-    .Call(`_arrow_dataset___DatasetFactory__Finish2` , factory, schema)
+    .Call(`_arrow_dataset___DatasetFactory__Finish2`, factory, schema)
 }
 
 dataset___DatasetFactory__Inspect <- function(factory, unify_schemas){
-    .Call(`_arrow_dataset___DatasetFactory__Inspect` , factory, unify_schemas)
+    .Call(`_arrow_dataset___DatasetFactory__Inspect`, factory, unify_schemas)
 }
 
 dataset___UnionDatasetFactory__Make <- function(children){
-    .Call(`_arrow_dataset___UnionDatasetFactory__Make` , children)
+    .Call(`_arrow_dataset___UnionDatasetFactory__Make`, children)
 }
 
 dataset___FileSystemDatasetFactory__Make2 <- function(fs, selector, format, partitioning){
-    .Call(`_arrow_dataset___FileSystemDatasetFactory__Make2` , fs, selector, format, partitioning)
+    .Call(`_arrow_dataset___FileSystemDatasetFactory__Make2`, fs, selector, format, partitioning)
 }
 
 dataset___FileSystemDatasetFactory__Make1 <- function(fs, selector, format){
-    .Call(`_arrow_dataset___FileSystemDatasetFactory__Make1` , fs, selector, format)
+    .Call(`_arrow_dataset___FileSystemDatasetFactory__Make1`, fs, selector, format)
 }
 
 dataset___FileSystemDatasetFactory__Make3 <- function(fs, selector, format, factory){
-    .Call(`_arrow_dataset___FileSystemDatasetFactory__Make3` , fs, selector, format, factory)
+    .Call(`_arrow_dataset___FileSystemDatasetFactory__Make3`, fs, selector, format, factory)
 }
 
 dataset___FileFormat__type_name <- function(format){
-    .Call(`_arrow_dataset___FileFormat__type_name` , format)
+    .Call(`_arrow_dataset___FileFormat__type_name`, format)
 }
 
 dataset___FileFormat__DefaultWriteOptions <- function(fmt){
-    .Call(`_arrow_dataset___FileFormat__DefaultWriteOptions` , fmt)
+    .Call(`_arrow_dataset___FileFormat__DefaultWriteOptions`, fmt)
 }
 
 dataset___ParquetFileFormat__Make <- function(use_buffered_stream, buffer_size, dict_columns){
-    .Call(`_arrow_dataset___ParquetFileFormat__Make` , use_buffered_stream, buffer_size, dict_columns)
+    .Call(`_arrow_dataset___ParquetFileFormat__Make`, use_buffered_stream, buffer_size, dict_columns)
 }
 
 dataset___FileWriteOptions__type_name <- function(options){
-    .Call(`_arrow_dataset___FileWriteOptions__type_name` , options)
+    .Call(`_arrow_dataset___FileWriteOptions__type_name`, options)
 }
 
 dataset___ParquetFileWriteOptions__update <- function(options, writer_props, arrow_writer_props){
-    invisible(.Call(`_arrow_dataset___ParquetFileWriteOptions__update` , options, writer_props, arrow_writer_props))
+    invisible(.Call(`_arrow_dataset___ParquetFileWriteOptions__update`, options, writer_props, arrow_writer_props))
 }
 
 dataset___IpcFileWriteOptions__update2 <- function(ipc_options, use_legacy_format, codec, metadata_version){
-    invisible(.Call(`_arrow_dataset___IpcFileWriteOptions__update2` , ipc_options, use_legacy_format, codec, metadata_version))
+    invisible(.Call(`_arrow_dataset___IpcFileWriteOptions__update2`, ipc_options, use_legacy_format, codec, metadata_version))
 }
 
 dataset___IpcFileWriteOptions__update1 <- function(ipc_options, use_legacy_format, metadata_version){
-    invisible(.Call(`_arrow_dataset___IpcFileWriteOptions__update1` , ipc_options, use_legacy_format, metadata_version))
+    invisible(.Call(`_arrow_dataset___IpcFileWriteOptions__update1`, ipc_options, use_legacy_format, metadata_version))
 }
 
 dataset___IpcFileFormat__Make <- function(){
-    .Call(`_arrow_dataset___IpcFileFormat__Make` )
+    .Call(`_arrow_dataset___IpcFileFormat__Make`)
 }
 
 dataset___CsvFileFormat__Make <- function(parse_options){
-    .Call(`_arrow_dataset___CsvFileFormat__Make` , parse_options)
+    .Call(`_arrow_dataset___CsvFileFormat__Make`, parse_options)
 }
 
 dataset___DirectoryPartitioning <- function(schm){
-    .Call(`_arrow_dataset___DirectoryPartitioning` , schm)
+    .Call(`_arrow_dataset___DirectoryPartitioning`, schm)
 }
 
 dataset___DirectoryPartitioning__MakeFactory <- function(field_names){
-    .Call(`_arrow_dataset___DirectoryPartitioning__MakeFactory` , field_names)
+    .Call(`_arrow_dataset___DirectoryPartitioning__MakeFactory`, field_names)
 }
 
 dataset___HivePartitioning <- function(schm){
-    .Call(`_arrow_dataset___HivePartitioning` , schm)
+    .Call(`_arrow_dataset___HivePartitioning`, schm)
 }
 
 dataset___HivePartitioning__MakeFactory <- function(){
-    .Call(`_arrow_dataset___HivePartitioning__MakeFactory` )
+    .Call(`_arrow_dataset___HivePartitioning__MakeFactory`)
 }
 
 dataset___ScannerBuilder__Project <- function(sb, cols){
-    invisible(.Call(`_arrow_dataset___ScannerBuilder__Project` , sb, cols))
+    invisible(.Call(`_arrow_dataset___ScannerBuilder__Project`, sb, cols))
 }
 
 dataset___ScannerBuilder__Filter <- function(sb, expr){
-    invisible(.Call(`_arrow_dataset___ScannerBuilder__Filter` , sb, expr))
+    invisible(.Call(`_arrow_dataset___ScannerBuilder__Filter`, sb, expr))
 }
 
 dataset___ScannerBuilder__UseThreads <- function(sb, threads){
-    invisible(.Call(`_arrow_dataset___ScannerBuilder__UseThreads` , sb, threads))
+    invisible(.Call(`_arrow_dataset___ScannerBuilder__UseThreads`, sb, threads))
 }
 
 dataset___ScannerBuilder__BatchSize <- function(sb, batch_size){
-    invisible(.Call(`_arrow_dataset___ScannerBuilder__BatchSize` , sb, batch_size))
+    invisible(.Call(`_arrow_dataset___ScannerBuilder__BatchSize`, sb, batch_size))
 }
 
 dataset___ScannerBuilder__schema <- function(sb){
-    .Call(`_arrow_dataset___ScannerBuilder__schema` , sb)
+    .Call(`_arrow_dataset___ScannerBuilder__schema`, sb)
 }
 
 dataset___ScannerBuilder__Finish <- function(sb){
-    .Call(`_arrow_dataset___ScannerBuilder__Finish` , sb)
+    .Call(`_arrow_dataset___ScannerBuilder__Finish`, sb)
 }
 
 dataset___Scanner__ToTable <- function(scanner){
-    .Call(`_arrow_dataset___Scanner__ToTable` , scanner)
+    .Call(`_arrow_dataset___Scanner__ToTable`, scanner)
 }
 
 dataset___Scanner__head <- function(scanner, n){
-    .Call(`_arrow_dataset___Scanner__head` , scanner, n)
+    .Call(`_arrow_dataset___Scanner__head`, scanner, n)
 }
 
 dataset___Scanner__Scan <- function(scanner){
-    .Call(`_arrow_dataset___Scanner__Scan` , scanner)
+    .Call(`_arrow_dataset___Scanner__Scan`, scanner)
 }
 
 dataset___Scanner__schema <- function(sc){
-    .Call(`_arrow_dataset___Scanner__schema` , sc)
+    .Call(`_arrow_dataset___Scanner__schema`, sc)
 }
 
 dataset___ScanTask__get_batches <- function(scan_task){
-    .Call(`_arrow_dataset___ScanTask__get_batches` , scan_task)
+    .Call(`_arrow_dataset___ScanTask__get_batches`, scan_task)
 }
 
 dataset___Dataset__Write <- function(file_write_options, filesystem, base_dir, partitioning, basename_template, scanner){
-    invisible(.Call(`_arrow_dataset___Dataset__Write` , file_write_options, filesystem, base_dir, partitioning, basename_template, scanner))
+    invisible(.Call(`_arrow_dataset___Dataset__Write`, file_write_options, filesystem, base_dir, partitioning, basename_template, scanner))
 }
 
 Int8__initialize <- function(){
-    .Call(`_arrow_Int8__initialize` )
+    .Call(`_arrow_Int8__initialize`)
 }
 
 Int16__initialize <- function(){
-    .Call(`_arrow_Int16__initialize` )
+    .Call(`_arrow_Int16__initialize`)
 }
 
 Int32__initialize <- function(){
-    .Call(`_arrow_Int32__initialize` )
+    .Call(`_arrow_Int32__initialize`)
 }
 
 Int64__initialize <- function(){
-    .Call(`_arrow_Int64__initialize` )
+    .Call(`_arrow_Int64__initialize`)
 }
 
 UInt8__initialize <- function(){
-    .Call(`_arrow_UInt8__initialize` )
+    .Call(`_arrow_UInt8__initialize`)
 }
 
 UInt16__initialize <- function(){
-    .Call(`_arrow_UInt16__initialize` )
+    .Call(`_arrow_UInt16__initialize`)
 }
 
 UInt32__initialize <- function(){
-    .Call(`_arrow_UInt32__initialize` )
+    .Call(`_arrow_UInt32__initialize`)
 }
 
 UInt64__initialize <- function(){
-    .Call(`_arrow_UInt64__initialize` )
+    .Call(`_arrow_UInt64__initialize`)
 }
 
 Float16__initialize <- function(){
-    .Call(`_arrow_Float16__initialize` )
+    .Call(`_arrow_Float16__initialize`)
 }
 
 Float32__initialize <- function(){
-    .Call(`_arrow_Float32__initialize` )
+    .Call(`_arrow_Float32__initialize`)
 }
 
 Float64__initialize <- function(){
-    .Call(`_arrow_Float64__initialize` )
+    .Call(`_arrow_Float64__initialize`)
 }
 
 Boolean__initialize <- function(){
-    .Call(`_arrow_Boolean__initialize` )
+    .Call(`_arrow_Boolean__initialize`)
 }
 
 Utf8__initialize <- function(){
-    .Call(`_arrow_Utf8__initialize` )
+    .Call(`_arrow_Utf8__initialize`)
 }
 
 LargeUtf8__initialize <- function(){
-    .Call(`_arrow_LargeUtf8__initialize` )
+    .Call(`_arrow_LargeUtf8__initialize`)
 }
 
 Binary__initialize <- function(){
-    .Call(`_arrow_Binary__initialize` )
+    .Call(`_arrow_Binary__initialize`)
 }
 
 LargeBinary__initialize <- function(){
-    .Call(`_arrow_LargeBinary__initialize` )
+    .Call(`_arrow_LargeBinary__initialize`)
 }
 
 Date32__initialize <- function(){
-    .Call(`_arrow_Date32__initialize` )
+    .Call(`_arrow_Date32__initialize`)
 }
 
 Date64__initialize <- function(){
-    .Call(`_arrow_Date64__initialize` )
+    .Call(`_arrow_Date64__initialize`)
 }
 
 Null__initialize <- function(){
-    .Call(`_arrow_Null__initialize` )
+    .Call(`_arrow_Null__initialize`)
 }
 
 Decimal128Type__initialize <- function(precision, scale){
-    .Call(`_arrow_Decimal128Type__initialize` , precision, scale)
+    .Call(`_arrow_Decimal128Type__initialize`, precision, scale)
 }
 
 FixedSizeBinary__initialize <- function(byte_width){
-    .Call(`_arrow_FixedSizeBinary__initialize` , byte_width)
+    .Call(`_arrow_FixedSizeBinary__initialize`, byte_width)
 }
 
 Timestamp__initialize <- function(unit, timezone){
-    .Call(`_arrow_Timestamp__initialize` , unit, timezone)
+    .Call(`_arrow_Timestamp__initialize`, unit, timezone)
 }
 
 Time32__initialize <- function(unit){
-    .Call(`_arrow_Time32__initialize` , unit)
+    .Call(`_arrow_Time32__initialize`, unit)
 }
 
 Time64__initialize <- function(unit){
-    .Call(`_arrow_Time64__initialize` , unit)
+    .Call(`_arrow_Time64__initialize`, unit)
 }
 
 list__ <- function(x){
-    .Call(`_arrow_list__` , x)
+    .Call(`_arrow_list__`, x)
 }
 
 large_list__ <- function(x){
-    .Call(`_arrow_large_list__` , x)
+    .Call(`_arrow_large_list__`, x)
 }
 
 fixed_size_list__ <- function(x, list_size){
-    .Call(`_arrow_fixed_size_list__` , x, list_size)
+    .Call(`_arrow_fixed_size_list__`, x, list_size)
 }
 
 struct__ <- function(fields){
-    .Call(`_arrow_struct__` , fields)
+    .Call(`_arrow_struct__`, fields)
 }
 
 DataType__ToString <- function(type){
-    .Call(`_arrow_DataType__ToString` , type)
+    .Call(`_arrow_DataType__ToString`, type)
 }
 
 DataType__name <- function(type){
-    .Call(`_arrow_DataType__name` , type)
+    .Call(`_arrow_DataType__name`, type)
 }
 
 DataType__Equals <- function(lhs, rhs){
-    .Call(`_arrow_DataType__Equals` , lhs, rhs)
+    .Call(`_arrow_DataType__Equals`, lhs, rhs)
 }
 
 DataType__num_fields <- function(type){
-    .Call(`_arrow_DataType__num_fields` , type)
+    .Call(`_arrow_DataType__num_fields`, type)
 }
 
 DataType__fields <- function(type){
-    .Call(`_arrow_DataType__fields` , type)
+    .Call(`_arrow_DataType__fields`, type)
 }
 
 DataType__id <- function(type){
-    .Call(`_arrow_DataType__id` , type)
+    .Call(`_arrow_DataType__id`, type)
 }
 
 ListType__ToString <- function(type){
-    .Call(`_arrow_ListType__ToString` , type)
+    .Call(`_arrow_ListType__ToString`, type)
 }
 
 FixedWidthType__bit_width <- function(type){
-    .Call(`_arrow_FixedWidthType__bit_width` , type)
+    .Call(`_arrow_FixedWidthType__bit_width`, type)
 }
 
 DateType__unit <- function(type){
-    .Call(`_arrow_DateType__unit` , type)
+    .Call(`_arrow_DateType__unit`, type)
 }
 
 TimeType__unit <- function(type){
-    .Call(`_arrow_TimeType__unit` , type)
+    .Call(`_arrow_TimeType__unit`, type)
 }
 
 DecimalType__precision <- function(type){
-    .Call(`_arrow_DecimalType__precision` , type)
+    .Call(`_arrow_DecimalType__precision`, type)
 }
 
 DecimalType__scale <- function(type){
-    .Call(`_arrow_DecimalType__scale` , type)
+    .Call(`_arrow_DecimalType__scale`, type)
 }
 
 TimestampType__timezone <- function(type){
-    .Call(`_arrow_TimestampType__timezone` , type)
+    .Call(`_arrow_TimestampType__timezone`, type)
 }
 
 TimestampType__unit <- function(type){
-    .Call(`_arrow_TimestampType__unit` , type)
+    .Call(`_arrow_TimestampType__unit`, type)
 }
 
 DictionaryType__initialize <- function(index_type, value_type, ordered){
-    .Call(`_arrow_DictionaryType__initialize` , index_type, value_type, ordered)
+    .Call(`_arrow_DictionaryType__initialize`, index_type, value_type, ordered)
 }
 
 DictionaryType__index_type <- function(type){
-    .Call(`_arrow_DictionaryType__index_type` , type)
+    .Call(`_arrow_DictionaryType__index_type`, type)
 }
 
 DictionaryType__value_type <- function(type){
-    .Call(`_arrow_DictionaryType__value_type` , type)
+    .Call(`_arrow_DictionaryType__value_type`, type)
 }
 
 DictionaryType__name <- function(type){
-    .Call(`_arrow_DictionaryType__name` , type)
+    .Call(`_arrow_DictionaryType__name`, type)
 }
 
 DictionaryType__ordered <- function(type){
-    .Call(`_arrow_DictionaryType__ordered` , type)
+    .Call(`_arrow_DictionaryType__ordered`, type)
 }
 
 StructType__GetFieldByName <- function(type, name){
-    .Call(`_arrow_StructType__GetFieldByName` , type, name)
+    .Call(`_arrow_StructType__GetFieldByName`, type, name)
 }
 
 StructType__GetFieldIndex <- function(type, name){
-    .Call(`_arrow_StructType__GetFieldIndex` , type, name)
+    .Call(`_arrow_StructType__GetFieldIndex`, type, name)
 }
 
 ListType__value_field <- function(type){
-    .Call(`_arrow_ListType__value_field` , type)
+    .Call(`_arrow_ListType__value_field`, type)
 }
 
 ListType__value_type <- function(type){
-    .Call(`_arrow_ListType__value_type` , type)
+    .Call(`_arrow_ListType__value_type`, type)
 }
 
 LargeListType__value_field <- function(type){
-    .Call(`_arrow_LargeListType__value_field` , type)
+    .Call(`_arrow_LargeListType__value_field`, type)
 }
 
 LargeListType__value_type <- function(type){
-    .Call(`_arrow_LargeListType__value_type` , type)
+    .Call(`_arrow_LargeListType__value_type`, type)
 }
 
 FixedSizeListType__value_field <- function(type){
-    .Call(`_arrow_FixedSizeListType__value_field` , type)
+    .Call(`_arrow_FixedSizeListType__value_field`, type)
 }
 
 FixedSizeListType__value_type <- function(type){
-    .Call(`_arrow_FixedSizeListType__value_type` , type)
+    .Call(`_arrow_FixedSizeListType__value_type`, type)
 }
 
 FixedSizeListType__list_size <- function(type){
-    .Call(`_arrow_FixedSizeListType__list_size` , type)
+    .Call(`_arrow_FixedSizeListType__list_size`, type)
 }
 
 dataset___expr__call <- function(func_name, argument_list, options){
-    .Call(`_arrow_dataset___expr__call` , func_name, argument_list, options)
+    .Call(`_arrow_dataset___expr__call`, func_name, argument_list, options)
 }
 
 dataset___expr__field_ref <- function(name){
-    .Call(`_arrow_dataset___expr__field_ref` , name)
+    .Call(`_arrow_dataset___expr__field_ref`, name)
 }
 
 dataset___expr__scalar <- function(x){
-    .Call(`_arrow_dataset___expr__scalar` , x)
+    .Call(`_arrow_dataset___expr__scalar`, x)
 }
 
 dataset___expr__ToString <- function(x){
-    .Call(`_arrow_dataset___expr__ToString` , x)
+    .Call(`_arrow_dataset___expr__ToString`, x)
 }
 
 ipc___WriteFeather__Table <- function(stream, table, version, chunk_size, compression, compression_level){
-    invisible(.Call(`_arrow_ipc___WriteFeather__Table` , stream, table, version, chunk_size, compression, compression_level))
+    invisible(.Call(`_arrow_ipc___WriteFeather__Table`, stream, table, version, chunk_size, compression, compression_level))
 }
 
 ipc___feather___Reader__version <- function(reader){
-    .Call(`_arrow_ipc___feather___Reader__version` , reader)
+    .Call(`_arrow_ipc___feather___Reader__version`, reader)
 }
 
 ipc___feather___Reader__Read <- function(reader, columns){
-    .Call(`_arrow_ipc___feather___Reader__Read` , reader, columns)
+    .Call(`_arrow_ipc___feather___Reader__Read`, reader, columns)
 }
 
 ipc___feather___Reader__Open <- function(stream){
-    .Call(`_arrow_ipc___feather___Reader__Open` , stream)
+    .Call(`_arrow_ipc___feather___Reader__Open`, stream)
 }
 
 ipc___feather___Reader__column_names <- function(reader){
-    .Call(`_arrow_ipc___feather___Reader__column_names` , reader)
+    .Call(`_arrow_ipc___feather___Reader__column_names`, reader)
 }
 
 Field__initialize <- function(name, field, nullable){
-    .Call(`_arrow_Field__initialize` , name, field, nullable)
+    .Call(`_arrow_Field__initialize`, name, field, nullable)
 }
 
 Field__ToString <- function(field){
-    .Call(`_arrow_Field__ToString` , field)
+    .Call(`_arrow_Field__ToString`, field)
 }
 
 Field__name <- function(field){
-    .Call(`_arrow_Field__name` , field)
+    .Call(`_arrow_Field__name`, field)
 }
 
 Field__Equals <- function(field, other){
-    .Call(`_arrow_Field__Equals` , field, other)
+    .Call(`_arrow_Field__Equals`, field, other)
 }
 
 Field__nullable <- function(field){
-    .Call(`_arrow_Field__nullable` , field)
+    .Call(`_arrow_Field__nullable`, field)
 }
 
 Field__type <- function(field){
-    .Call(`_arrow_Field__type` , field)
+    .Call(`_arrow_Field__type`, field)
 }
 
 fs___FileInfo__type <- function(x){
-    .Call(`_arrow_fs___FileInfo__type` , x)
+    .Call(`_arrow_fs___FileInfo__type`, x)
 }
 
 fs___FileInfo__set_type <- function(x, type){
-    invisible(.Call(`_arrow_fs___FileInfo__set_type` , x, type))
+    invisible(.Call(`_arrow_fs___FileInfo__set_type`, x, type))
 }
 
 fs___FileInfo__path <- function(x){
-    .Call(`_arrow_fs___FileInfo__path` , x)
+    .Call(`_arrow_fs___FileInfo__path`, x)
 }
 
 fs___FileInfo__set_path <- function(x, path){
-    invisible(.Call(`_arrow_fs___FileInfo__set_path` , x, path))
+    invisible(.Call(`_arrow_fs___FileInfo__set_path`, x, path))
 }
 
 fs___FileInfo__size <- function(x){
-    .Call(`_arrow_fs___FileInfo__size` , x)
+    .Call(`_arrow_fs___FileInfo__size`, x)
 }
 
 fs___FileInfo__set_size <- function(x, size){
-    invisible(.Call(`_arrow_fs___FileInfo__set_size` , x, size))
+    invisible(.Call(`_arrow_fs___FileInfo__set_size`, x, size))
 }
 
 fs___FileInfo__base_name <- function(x){
-    .Call(`_arrow_fs___FileInfo__base_name` , x)
+    .Call(`_arrow_fs___FileInfo__base_name`, x)
 }
 
 fs___FileInfo__extension <- function(x){
-    .Call(`_arrow_fs___FileInfo__extension` , x)
+    .Call(`_arrow_fs___FileInfo__extension`, x)
 }
 
 fs___FileInfo__mtime <- function(x){
-    .Call(`_arrow_fs___FileInfo__mtime` , x)
+    .Call(`_arrow_fs___FileInfo__mtime`, x)
 }
 
 fs___FileInfo__set_mtime <- function(x, time){
-    invisible(.Call(`_arrow_fs___FileInfo__set_mtime` , x, time))
+    invisible(.Call(`_arrow_fs___FileInfo__set_mtime`, x, time))
 }
 
 fs___FileSelector__base_dir <- function(selector){
-    .Call(`_arrow_fs___FileSelector__base_dir` , selector)
+    .Call(`_arrow_fs___FileSelector__base_dir`, selector)
 }
 
 fs___FileSelector__allow_not_found <- function(selector){
-    .Call(`_arrow_fs___FileSelector__allow_not_found` , selector)
+    .Call(`_arrow_fs___FileSelector__allow_not_found`, selector)
 }
 
 fs___FileSelector__recursive <- function(selector){
-    .Call(`_arrow_fs___FileSelector__recursive` , selector)
+    .Call(`_arrow_fs___FileSelector__recursive`, selector)
 }
 
 fs___FileSelector__create <- function(base_dir, allow_not_found, recursive){
-    .Call(`_arrow_fs___FileSelector__create` , base_dir, allow_not_found, recursive)
+    .Call(`_arrow_fs___FileSelector__create`, base_dir, allow_not_found, recursive)
 }
 
 fs___FileSystem__GetTargetInfos_Paths <- function(file_system, paths){
-    .Call(`_arrow_fs___FileSystem__GetTargetInfos_Paths` , file_system, paths)
+    .Call(`_arrow_fs___FileSystem__GetTargetInfos_Paths`, file_system, paths)
 }
 
 fs___FileSystem__GetTargetInfos_FileSelector <- function(file_system, selector){
-    .Call(`_arrow_fs___FileSystem__GetTargetInfos_FileSelector` , file_system, selector)
+    .Call(`_arrow_fs___FileSystem__GetTargetInfos_FileSelector`, file_system, selector)
 }
 
 fs___FileSystem__CreateDir <- function(file_system, path, recursive){
-    invisible(.Call(`_arrow_fs___FileSystem__CreateDir` , file_system, path, recursive))
+    invisible(.Call(`_arrow_fs___FileSystem__CreateDir`, file_system, path, recursive))
 }
 
 fs___FileSystem__DeleteDir <- function(file_system, path){
-    invisible(.Call(`_arrow_fs___FileSystem__DeleteDir` , file_system, path))
+    invisible(.Call(`_arrow_fs___FileSystem__DeleteDir`, file_system, path))
 }
 
 fs___FileSystem__DeleteDirContents <- function(file_system, path){
-    invisible(.Call(`_arrow_fs___FileSystem__DeleteDirContents` , file_system, path))
+    invisible(.Call(`_arrow_fs___FileSystem__DeleteDirContents`, file_system, path))
 }
 
 fs___FileSystem__DeleteFile <- function(file_system, path){
-    invisible(.Call(`_arrow_fs___FileSystem__DeleteFile` , file_system, path))
+    invisible(.Call(`_arrow_fs___FileSystem__DeleteFile`, file_system, path))
 }
 
 fs___FileSystem__DeleteFiles <- function(file_system, paths){
-    invisible(.Call(`_arrow_fs___FileSystem__DeleteFiles` , file_system, paths))
+    invisible(.Call(`_arrow_fs___FileSystem__DeleteFiles`, file_system, paths))
 }
 
 fs___FileSystem__Move <- function(file_system, src, dest){
-    invisible(.Call(`_arrow_fs___FileSystem__Move` , file_system, src, dest))
+    invisible(.Call(`_arrow_fs___FileSystem__Move`, file_system, src, dest))
 }
 
 fs___FileSystem__CopyFile <- function(file_system, src, dest){
-    invisible(.Call(`_arrow_fs___FileSystem__CopyFile` , file_system, src, dest))
+    invisible(.Call(`_arrow_fs___FileSystem__CopyFile`, file_system, src, dest))
 }
 
 fs___FileSystem__OpenInputStream <- function(file_system, path){
-    .Call(`_arrow_fs___FileSystem__OpenInputStream` , file_system, path)
+    .Call(`_arrow_fs___FileSystem__OpenInputStream`, file_system, path)
 }
 
 fs___FileSystem__OpenInputFile <- function(file_system, path){
-    .Call(`_arrow_fs___FileSystem__OpenInputFile` , file_system, path)
+    .Call(`_arrow_fs___FileSystem__OpenInputFile`, file_system, path)
 }
 
 fs___FileSystem__OpenOutputStream <- function(file_system, path){
-    .Call(`_arrow_fs___FileSystem__OpenOutputStream` , file_system, path)
+    .Call(`_arrow_fs___FileSystem__OpenOutputStream`, file_system, path)
 }
 
 fs___FileSystem__OpenAppendStream <- function(file_system, path){
-    .Call(`_arrow_fs___FileSystem__OpenAppendStream` , file_system, path)
+    .Call(`_arrow_fs___FileSystem__OpenAppendStream`, file_system, path)
 }
 
 fs___FileSystem__type_name <- function(file_system){
-    .Call(`_arrow_fs___FileSystem__type_name` , file_system)
+    .Call(`_arrow_fs___FileSystem__type_name`, file_system)
 }
 
 fs___LocalFileSystem__create <- function(){
-    .Call(`_arrow_fs___LocalFileSystem__create` )
+    .Call(`_arrow_fs___LocalFileSystem__create`)
 }
 
 fs___SubTreeFileSystem__create <- function(base_path, base_fs){
-    .Call(`_arrow_fs___SubTreeFileSystem__create` , base_path, base_fs)
+    .Call(`_arrow_fs___SubTreeFileSystem__create`, base_path, base_fs)
 }
 
 fs___SubTreeFileSystem__base_fs <- function(file_system){
-    .Call(`_arrow_fs___SubTreeFileSystem__base_fs` , file_system)
+    .Call(`_arrow_fs___SubTreeFileSystem__base_fs`, file_system)
 }
 
 fs___SubTreeFileSystem__base_path <- function(file_system){
-    .Call(`_arrow_fs___SubTreeFileSystem__base_path` , file_system)
+    .Call(`_arrow_fs___SubTreeFileSystem__base_path`, file_system)
 }
 
 fs___FileSystemFromUri <- function(path){
-    .Call(`_arrow_fs___FileSystemFromUri` , path)
+    .Call(`_arrow_fs___FileSystemFromUri`, path)
 }
 
 fs___CopyFiles <- function(source_fs, source_sel, destination_fs, destination_base_dir, chunk_size, use_threads){
-    invisible(.Call(`_arrow_fs___CopyFiles` , source_fs, source_sel, destination_fs, destination_base_dir, chunk_size, use_threads))
+    invisible(.Call(`_arrow_fs___CopyFiles`, source_fs, source_sel, destination_fs, destination_base_dir, chunk_size, use_threads))
 }
 
 fs___S3FileSystem__create <- function(anonymous, access_key, secret_key, session_token, role_arn, session_name, external_id, load_frequency, region, endpoint_override, scheme, background_writes){
-    .Call(`_arrow_fs___S3FileSystem__create` , anonymous, access_key, secret_key, session_token, role_arn, session_name, external_id, load_frequency, region, endpoint_override, scheme, background_writes)
+    .Call(`_arrow_fs___S3FileSystem__create`, anonymous, access_key, secret_key, session_token, role_arn, session_name, external_id, load_frequency, region, endpoint_override, scheme, background_writes)
 }
 
 fs___S3FileSystem__region <- function(fs){
-    .Call(`_arrow_fs___S3FileSystem__region` , fs)
+    .Call(`_arrow_fs___S3FileSystem__region`, fs)
 }
 
 io___Readable__Read <- function(x, nbytes){
-    .Call(`_arrow_io___Readable__Read` , x, nbytes)
+    .Call(`_arrow_io___Readable__Read`, x, nbytes)
 }
 
 io___InputStream__Close <- function(x){
-    invisible(.Call(`_arrow_io___InputStream__Close` , x))
+    invisible(.Call(`_arrow_io___InputStream__Close`, x))
 }
 
 io___OutputStream__Close <- function(x){
-    invisible(.Call(`_arrow_io___OutputStream__Close` , x))
+    invisible(.Call(`_arrow_io___OutputStream__Close`, x))
 }
 
 io___RandomAccessFile__GetSize <- function(x){
-    .Call(`_arrow_io___RandomAccessFile__GetSize` , x)
+    .Call(`_arrow_io___RandomAccessFile__GetSize`, x)
 }
 
 io___RandomAccessFile__supports_zero_copy <- function(x){
-    .Call(`_arrow_io___RandomAccessFile__supports_zero_copy` , x)
+    .Call(`_arrow_io___RandomAccessFile__supports_zero_copy`, x)
 }
 
 io___RandomAccessFile__Seek <- function(x, position){
-    invisible(.Call(`_arrow_io___RandomAccessFile__Seek` , x, position))
+    invisible(.Call(`_arrow_io___RandomAccessFile__Seek`, x, position))
 }
 
 io___RandomAccessFile__Tell <- function(x){
-    .Call(`_arrow_io___RandomAccessFile__Tell` , x)
+    .Call(`_arrow_io___RandomAccessFile__Tell`, x)
 }
 
 io___RandomAccessFile__Read0 <- function(x){
-    .Call(`_arrow_io___RandomAccessFile__Read0` , x)
+    .Call(`_arrow_io___RandomAccessFile__Read0`, x)
 }
 
 io___RandomAccessFile__ReadAt <- function(x, position, nbytes){
-    .Call(`_arrow_io___RandomAccessFile__ReadAt` , x, position, nbytes)
+    .Call(`_arrow_io___RandomAccessFile__ReadAt`, x, position, nbytes)
 }
 
 io___MemoryMappedFile__Create <- function(path, size){
-    .Call(`_arrow_io___MemoryMappedFile__Create` , path, size)
+    .Call(`_arrow_io___MemoryMappedFile__Create`, path, size)
 }
 
 io___MemoryMappedFile__Open <- function(path, mode){
-    .Call(`_arrow_io___MemoryMappedFile__Open` , path, mode)
+    .Call(`_arrow_io___MemoryMappedFile__Open`, path, mode)
 }
 
 io___MemoryMappedFile__Resize <- function(x, size){
-    invisible(.Call(`_arrow_io___MemoryMappedFile__Resize` , x, size))
+    invisible(.Call(`_arrow_io___MemoryMappedFile__Resize`, x, size))
 }
 
 io___ReadableFile__Open <- function(path){
-    .Call(`_arrow_io___ReadableFile__Open` , path)
+    .Call(`_arrow_io___ReadableFile__Open`, path)
 }
 
 io___BufferReader__initialize <- function(buffer){
-    .Call(`_arrow_io___BufferReader__initialize` , buffer)
+    .Call(`_arrow_io___BufferReader__initialize`, buffer)
 }
 
 io___Writable__write <- function(stream, buf){
-    invisible(.Call(`_arrow_io___Writable__write` , stream, buf))
+    invisible(.Call(`_arrow_io___Writable__write`, stream, buf))
 }
 
 io___OutputStream__Tell <- function(stream){
-    .Call(`_arrow_io___OutputStream__Tell` , stream)
+    .Call(`_arrow_io___OutputStream__Tell`, stream)
 }
 
 io___FileOutputStream__Open <- function(path){
-    .Call(`_arrow_io___FileOutputStream__Open` , path)
+    .Call(`_arrow_io___FileOutputStream__Open`, path)
 }
 
 io___BufferOutputStream__Create <- function(initial_capacity){
-    .Call(`_arrow_io___BufferOutputStream__Create` , initial_capacity)
+    .Call(`_arrow_io___BufferOutputStream__Create`, initial_capacity)
 }
 
 io___BufferOutputStream__capacity <- function(stream){
-    .Call(`_arrow_io___BufferOutputStream__capacity` , stream)
+    .Call(`_arrow_io___BufferOutputStream__capacity`, stream)
 }
 
 io___BufferOutputStream__Finish <- function(stream){
-    .Call(`_arrow_io___BufferOutputStream__Finish` , stream)
+    .Call(`_arrow_io___BufferOutputStream__Finish`, stream)
 }
 
 io___BufferOutputStream__Tell <- function(stream){
-    .Call(`_arrow_io___BufferOutputStream__Tell` , stream)
+    .Call(`_arrow_io___BufferOutputStream__Tell`, stream)
 }
 
 io___BufferOutputStream__Write <- function(stream, bytes){
-    invisible(.Call(`_arrow_io___BufferOutputStream__Write` , stream, bytes))
+    invisible(.Call(`_arrow_io___BufferOutputStream__Write`, stream, bytes))
 }
 
 json___ReadOptions__initialize <- function(use_threads, block_size){
-    .Call(`_arrow_json___ReadOptions__initialize` , use_threads, block_size)
+    .Call(`_arrow_json___ReadOptions__initialize`, use_threads, block_size)
 }
 
 json___ParseOptions__initialize <- function(newlines_in_values){
-    .Call(`_arrow_json___ParseOptions__initialize` , newlines_in_values)
+    .Call(`_arrow_json___ParseOptions__initialize`, newlines_in_values)
 }
 
 json___TableReader__Make <- function(input, read_options, parse_options){
-    .Call(`_arrow_json___TableReader__Make` , input, read_options, parse_options)
+    .Call(`_arrow_json___TableReader__Make`, input, read_options, parse_options)
 }
 
 json___TableReader__Read <- function(table_reader){
-    .Call(`_arrow_json___TableReader__Read` , table_reader)
+    .Call(`_arrow_json___TableReader__Read`, table_reader)
 }
 
 MemoryPool__default <- function(){
-    .Call(`_arrow_MemoryPool__default` )
+    .Call(`_arrow_MemoryPool__default`)
 }
 
 MemoryPool__bytes_allocated <- function(pool){
-    .Call(`_arrow_MemoryPool__bytes_allocated` , pool)
+    .Call(`_arrow_MemoryPool__bytes_allocated`, pool)
 }
 
 MemoryPool__max_memory <- function(pool){
-    .Call(`_arrow_MemoryPool__max_memory` , pool)
+    .Call(`_arrow_MemoryPool__max_memory`, pool)
 }
 
 MemoryPool__backend_name <- function(pool){
-    .Call(`_arrow_MemoryPool__backend_name` , pool)
+    .Call(`_arrow_MemoryPool__backend_name`, pool)
 }
 
 supported_memory_backends <- function(){
-    .Call(`_arrow_supported_memory_backends` )
+    .Call(`_arrow_supported_memory_backends`)
 }
 
 ipc___Message__body_length <- function(message){
-    .Call(`_arrow_ipc___Message__body_length` , message)
+    .Call(`_arrow_ipc___Message__body_length`, message)
 }
 
 ipc___Message__metadata <- function(message){
-    .Call(`_arrow_ipc___Message__metadata` , message)
+    .Call(`_arrow_ipc___Message__metadata`, message)
 }
 
 ipc___Message__body <- function(message){
-    .Call(`_arrow_ipc___Message__body` , message)
+    .Call(`_arrow_ipc___Message__body`, message)
 }
 
 ipc___Message__Verify <- function(message){
-    .Call(`_arrow_ipc___Message__Verify` , message)
+    .Call(`_arrow_ipc___Message__Verify`, message)
 }
 
 ipc___Message__type <- function(message){
-    .Call(`_arrow_ipc___Message__type` , message)
+    .Call(`_arrow_ipc___Message__type`, message)
 }
 
 ipc___Message__Equals <- function(x, y){
-    .Call(`_arrow_ipc___Message__Equals` , x, y)
+    .Call(`_arrow_ipc___Message__Equals`, x, y)
 }
 
 ipc___ReadRecordBatch__Message__Schema <- function(message, schema){
-    .Call(`_arrow_ipc___ReadRecordBatch__Message__Schema` , message, schema)
+    .Call(`_arrow_ipc___ReadRecordBatch__Message__Schema`, message, schema)
 }
 
 ipc___ReadSchema_InputStream <- function(stream){
-    .Call(`_arrow_ipc___ReadSchema_InputStream` , stream)
+    .Call(`_arrow_ipc___ReadSchema_InputStream`, stream)
 }
 
 ipc___ReadSchema_Message <- function(message){
-    .Call(`_arrow_ipc___ReadSchema_Message` , message)
+    .Call(`_arrow_ipc___ReadSchema_Message`, message)
 }
 
 ipc___MessageReader__Open <- function(stream){
-    .Call(`_arrow_ipc___MessageReader__Open` , stream)
+    .Call(`_arrow_ipc___MessageReader__Open`, stream)
 }
 
 ipc___MessageReader__ReadNextMessage <- function(reader){
-    .Call(`_arrow_ipc___MessageReader__ReadNextMessage` , reader)
+    .Call(`_arrow_ipc___MessageReader__ReadNextMessage`, reader)
 }
 
 ipc___ReadMessage <- function(stream){
-    .Call(`_arrow_ipc___ReadMessage` , stream)
+    .Call(`_arrow_ipc___ReadMessage`, stream)
 }
 
 parquet___arrow___ArrowReaderProperties__Make <- function(use_threads){
-    .Call(`_arrow_parquet___arrow___ArrowReaderProperties__Make` , use_threads)
+    .Call(`_arrow_parquet___arrow___ArrowReaderProperties__Make`, use_threads)
 }
 
 parquet___arrow___ArrowReaderProperties__set_use_threads <- function(properties, use_threads){
-    invisible(.Call(`_arrow_parquet___arrow___ArrowReaderProperties__set_use_threads` , properties, use_threads))
+    invisible(.Call(`_arrow_parquet___arrow___ArrowReaderProperties__set_use_threads`, properties, use_threads))
 }
 
 parquet___arrow___ArrowReaderProperties__get_use_threads <- function(properties, use_threads){
-    .Call(`_arrow_parquet___arrow___ArrowReaderProperties__get_use_threads` , properties, use_threads)
+    .Call(`_arrow_parquet___arrow___ArrowReaderProperties__get_use_threads`, properties, use_threads)
 }
 
 parquet___arrow___ArrowReaderProperties__get_read_dictionary <- function(properties, column_index){
-    .Call(`_arrow_parquet___arrow___ArrowReaderProperties__get_read_dictionary` , properties, column_index)
+    .Call(`_arrow_parquet___arrow___ArrowReaderProperties__get_read_dictionary`, properties, column_index)
 }
 
 parquet___arrow___ArrowReaderProperties__set_read_dictionary <- function(properties, column_index, read_dict){
-    invisible(.Call(`_arrow_parquet___arrow___ArrowReaderProperties__set_read_dictionary` , properties, column_index, read_dict))
+    invisible(.Call(`_arrow_parquet___arrow___ArrowReaderProperties__set_read_dictionary`, properties, column_index, read_dict))
 }
 
 parquet___arrow___FileReader__OpenFile <- function(file, props){
-    .Call(`_arrow_parquet___arrow___FileReader__OpenFile` , file, props)
+    .Call(`_arrow_parquet___arrow___FileReader__OpenFile`, file, props)
 }
 
 parquet___arrow___FileReader__ReadTable1 <- function(reader){
-    .Call(`_arrow_parquet___arrow___FileReader__ReadTable1` , reader)
+    .Call(`_arrow_parquet___arrow___FileReader__ReadTable1`, reader)
 }
 
 parquet___arrow___FileReader__ReadTable2 <- function(reader, column_indices){
-    .Call(`_arrow_parquet___arrow___FileReader__ReadTable2` , reader, column_indices)
+    .Call(`_arrow_parquet___arrow___FileReader__ReadTable2`, reader, column_indices)
 }
 
 parquet___arrow___FileReader__ReadRowGroup1 <- function(reader, i){
-    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroup1` , reader, i)
+    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroup1`, reader, i)
 }
 
 parquet___arrow___FileReader__ReadRowGroup2 <- function(reader, i, column_indices){
-    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroup2` , reader, i, column_indices)
+    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroup2`, reader, i, column_indices)
 }
 
 parquet___arrow___FileReader__ReadRowGroups1 <- function(reader, row_groups){
-    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroups1` , reader, row_groups)
+    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroups1`, reader, row_groups)
 }
 
 parquet___arrow___FileReader__ReadRowGroups2 <- function(reader, row_groups, column_indices){
-    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroups2` , reader, row_groups, column_indices)
+    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroups2`, reader, row_groups, column_indices)
 }
 
 parquet___arrow___FileReader__num_rows <- function(reader){
-    .Call(`_arrow_parquet___arrow___FileReader__num_rows` , reader)
+    .Call(`_arrow_parquet___arrow___FileReader__num_rows`, reader)
 }
 
 parquet___arrow___FileReader__num_columns <- function(reader){
-    .Call(`_arrow_parquet___arrow___FileReader__num_columns` , reader)
+    .Call(`_arrow_parquet___arrow___FileReader__num_columns`, reader)
 }
 
 parquet___arrow___FileReader__num_row_groups <- function(reader){
-    .Call(`_arrow_parquet___arrow___FileReader__num_row_groups` , reader)
+    .Call(`_arrow_parquet___arrow___FileReader__num_row_groups`, reader)
 }
 
 parquet___arrow___FileReader__ReadColumn <- function(reader, i){
-    .Call(`_arrow_parquet___arrow___FileReader__ReadColumn` , reader, i)
+    .Call(`_arrow_parquet___arrow___FileReader__ReadColumn`, reader, i)
 }
 
 parquet___ArrowWriterProperties___create <- function(allow_truncated_timestamps, use_deprecated_int96_timestamps, timestamp_unit){
-    .Call(`_arrow_parquet___ArrowWriterProperties___create` , allow_truncated_timestamps, use_deprecated_int96_timestamps, timestamp_unit)
+    .Call(`_arrow_parquet___ArrowWriterProperties___create`, allow_truncated_timestamps, use_deprecated_int96_timestamps, timestamp_unit)
 }
 
 parquet___WriterProperties___Builder__create <- function(){
-    .Call(`_arrow_parquet___WriterProperties___Builder__create` )
+    .Call(`_arrow_parquet___WriterProperties___Builder__create`)
 }
 
 parquet___WriterProperties___Builder__version <- function(builder, version){
-    invisible(.Call(`_arrow_parquet___WriterProperties___Builder__version` , builder, version))
+    invisible(.Call(`_arrow_parquet___WriterProperties___Builder__version`, builder, version))
 }
 
 parquet___ArrowWriterProperties___Builder__set_compressions <- function(builder, paths, types){
-    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_compressions` , builder, paths, types))
+    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_compressions`, builder, paths, types))
 }
 
 parquet___ArrowWriterProperties___Builder__set_compression_levels <- function(builder, paths, levels){
-    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_compression_levels` , builder, paths, levels))
+    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_compression_levels`, builder, paths, levels))
 }
 
 parquet___ArrowWriterProperties___Builder__set_use_dictionary <- function(builder, paths, use_dictionary){
-    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_use_dictionary` , builder, paths, use_dictionary))
+    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_use_dictionary`, builder, paths, use_dictionary))
 }
 
 parquet___ArrowWriterProperties___Builder__set_write_statistics <- function(builder, paths, write_statistics){
-    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_write_statistics` , builder, paths, write_statistics))
+    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_write_statistics`, builder, paths, write_statistics))
 }
 
 parquet___ArrowWriterProperties___Builder__data_page_size <- function(builder, data_page_size){
-    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__data_page_size` , builder, data_page_size))
+    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__data_page_size`, builder, data_page_size))
 }
 
 parquet___WriterProperties___Builder__build <- function(builder){
-    .Call(`_arrow_parquet___WriterProperties___Builder__build` , builder)
+    .Call(`_arrow_parquet___WriterProperties___Builder__build`, builder)
 }
 
 parquet___arrow___ParquetFileWriter__Open <- function(schema, sink, properties, arrow_properties){
-    .Call(`_arrow_parquet___arrow___ParquetFileWriter__Open` , schema, sink, properties, arrow_properties)
+    .Call(`_arrow_parquet___arrow___ParquetFileWriter__Open`, schema, sink, properties, arrow_properties)
 }
 
 parquet___arrow___FileWriter__WriteTable <- function(writer, table, chunk_size){
-    invisible(.Call(`_arrow_parquet___arrow___FileWriter__WriteTable` , writer, table, chunk_size))
+    invisible(.Call(`_arrow_parquet___arrow___FileWriter__WriteTable`, writer, table, chunk_size))
 }
 
 parquet___arrow___FileWriter__Close <- function(writer){
-    invisible(.Call(`_arrow_parquet___arrow___FileWriter__Close` , writer))
+    invisible(.Call(`_arrow_parquet___arrow___FileWriter__Close`, writer))
 }
 
 parquet___arrow___WriteTable <- function(table, sink, properties, arrow_properties){
-    invisible(.Call(`_arrow_parquet___arrow___WriteTable` , table, sink, properties, arrow_properties))
+    invisible(.Call(`_arrow_parquet___arrow___WriteTable`, table, sink, properties, arrow_properties))
 }
 
 parquet___arrow___FileReader__GetSchema <- function(reader){
-    .Call(`_arrow_parquet___arrow___FileReader__GetSchema` , reader)
+    .Call(`_arrow_parquet___arrow___FileReader__GetSchema`, reader)
 }
 
 ImportArray <- function(array, schema){
-    .Call(`_arrow_ImportArray` , array, schema)
+    .Call(`_arrow_ImportArray`, array, schema)
 }
 
 ImportRecordBatch <- function(array, schema){
-    .Call(`_arrow_ImportRecordBatch` , array, schema)
+    .Call(`_arrow_ImportRecordBatch`, array, schema)
 }
 
 ImportSchema <- function(schema){
-    .Call(`_arrow_ImportSchema` , schema)
+    .Call(`_arrow_ImportSchema`, schema)
 }
 
 allocate_arrow_schema <- function(){
-    .Call(`_arrow_allocate_arrow_schema` )
+    .Call(`_arrow_allocate_arrow_schema`)
 }
 
 delete_arrow_schema <- function(ptr){
-    invisible(.Call(`_arrow_delete_arrow_schema` , ptr))
+    invisible(.Call(`_arrow_delete_arrow_schema`, ptr))
 }
 
 allocate_arrow_array <- function(){
-    .Call(`_arrow_allocate_arrow_array` )
+    .Call(`_arrow_allocate_arrow_array`)
 }
 
 delete_arrow_array <- function(ptr){
-    invisible(.Call(`_arrow_delete_arrow_array` , ptr))
+    invisible(.Call(`_arrow_delete_arrow_array`, ptr))
 }
 
 ExportType <- function(type, ptr){
-    invisible(.Call(`_arrow_ExportType` , type, ptr))
+    invisible(.Call(`_arrow_ExportType`, type, ptr))
 }
 
 ExportSchema <- function(schema, ptr){
-    invisible(.Call(`_arrow_ExportSchema` , schema, ptr))
+    invisible(.Call(`_arrow_ExportSchema`, schema, ptr))
 }
 
 ExportArray <- function(array, array_ptr, schema_ptr){
-    invisible(.Call(`_arrow_ExportArray` , array, array_ptr, schema_ptr))
+    invisible(.Call(`_arrow_ExportArray`, array, array_ptr, schema_ptr))
 }
 
 ExportRecordBatch <- function(batch, array_ptr, schema_ptr){
-    invisible(.Call(`_arrow_ExportRecordBatch` , batch, array_ptr, schema_ptr))
+    invisible(.Call(`_arrow_ExportRecordBatch`, batch, array_ptr, schema_ptr))
 }
 
 RecordBatch__num_columns <- function(x){
-    .Call(`_arrow_RecordBatch__num_columns` , x)
+    .Call(`_arrow_RecordBatch__num_columns`, x)
 }
 
 RecordBatch__num_rows <- function(x){
-    .Call(`_arrow_RecordBatch__num_rows` , x)
+    .Call(`_arrow_RecordBatch__num_rows`, x)
 }
 
 RecordBatch__schema <- function(x){
-    .Call(`_arrow_RecordBatch__schema` , x)
+    .Call(`_arrow_RecordBatch__schema`, x)
 }
 
 RecordBatch__RenameColumns <- function(batch, names){
-    .Call(`_arrow_RecordBatch__RenameColumns` , batch, names)
+    .Call(`_arrow_RecordBatch__RenameColumns`, batch, names)
 }
 
 RecordBatch__ReplaceSchemaMetadata <- function(x, metadata){
-    .Call(`_arrow_RecordBatch__ReplaceSchemaMetadata` , x, metadata)
+    .Call(`_arrow_RecordBatch__ReplaceSchemaMetadata`, x, metadata)
 }
 
 RecordBatch__columns <- function(batch){
-    .Call(`_arrow_RecordBatch__columns` , batch)
+    .Call(`_arrow_RecordBatch__columns`, batch)
 }
 
 RecordBatch__column <- function(batch, i){
-    .Call(`_arrow_RecordBatch__column` , batch, i)
+    .Call(`_arrow_RecordBatch__column`, batch, i)
 }
 
 RecordBatch__GetColumnByName <- function(batch, name){
-    .Call(`_arrow_RecordBatch__GetColumnByName` , batch, name)
+    .Call(`_arrow_RecordBatch__GetColumnByName`, batch, name)
 }
 
 RecordBatch__SelectColumns <- function(batch, indices){
-    .Call(`_arrow_RecordBatch__SelectColumns` , batch, indices)
+    .Call(`_arrow_RecordBatch__SelectColumns`, batch, indices)
 }
 
 RecordBatch__Equals <- function(self, other, check_metadata){
-    .Call(`_arrow_RecordBatch__Equals` , self, other, check_metadata)
+    .Call(`_arrow_RecordBatch__Equals`, self, other, check_metadata)
 }
 
 RecordBatch__RemoveColumn <- function(batch, i){
-    .Call(`_arrow_RecordBatch__RemoveColumn` , batch, i)
+    .Call(`_arrow_RecordBatch__RemoveColumn`, batch, i)
 }
 
 RecordBatch__column_name <- function(batch, i){
-    .Call(`_arrow_RecordBatch__column_name` , batch, i)
+    .Call(`_arrow_RecordBatch__column_name`, batch, i)
 }
 
 RecordBatch__names <- function(batch){
-    .Call(`_arrow_RecordBatch__names` , batch)
+    .Call(`_arrow_RecordBatch__names`, batch)
 }
 
 RecordBatch__Slice1 <- function(self, offset){
-    .Call(`_arrow_RecordBatch__Slice1` , self, offset)
+    .Call(`_arrow_RecordBatch__Slice1`, self, offset)
 }
 
 RecordBatch__Slice2 <- function(self, offset, length){
-    .Call(`_arrow_RecordBatch__Slice2` , self, offset, length)
+    .Call(`_arrow_RecordBatch__Slice2`, self, offset, length)
 }
 
 ipc___SerializeRecordBatch__Raw <- function(batch){
-    .Call(`_arrow_ipc___SerializeRecordBatch__Raw` , batch)
+    .Call(`_arrow_ipc___SerializeRecordBatch__Raw`, batch)
 }
 
 ipc___ReadRecordBatch__InputStream__Schema <- function(stream, schema){
-    .Call(`_arrow_ipc___ReadRecordBatch__InputStream__Schema` , stream, schema)
+    .Call(`_arrow_ipc___ReadRecordBatch__InputStream__Schema`, stream, schema)
 }
 
 RecordBatch__from_arrays <- function(schema_sxp, lst){
-    .Call(`_arrow_RecordBatch__from_arrays` , schema_sxp, lst)
+    .Call(`_arrow_RecordBatch__from_arrays`, schema_sxp, lst)
 }
 
 RecordBatchReader__schema <- function(reader){
-    .Call(`_arrow_RecordBatchReader__schema` , reader)
+    .Call(`_arrow_RecordBatchReader__schema`, reader)
 }
 
 RecordBatchReader__ReadNext <- function(reader){
-    .Call(`_arrow_RecordBatchReader__ReadNext` , reader)
+    .Call(`_arrow_RecordBatchReader__ReadNext`, reader)
 }
 
 ipc___RecordBatchStreamReader__Open <- function(stream){
-    .Call(`_arrow_ipc___RecordBatchStreamReader__Open` , stream)
+    .Call(`_arrow_ipc___RecordBatchStreamReader__Open`, stream)
 }
 
 ipc___RecordBatchStreamReader__batches <- function(reader){
-    .Call(`_arrow_ipc___RecordBatchStreamReader__batches` , reader)
+    .Call(`_arrow_ipc___RecordBatchStreamReader__batches`, reader)
 }
 
 ipc___RecordBatchFileReader__schema <- function(reader){
-    .Call(`_arrow_ipc___RecordBatchFileReader__schema` , reader)
+    .Call(`_arrow_ipc___RecordBatchFileReader__schema`, reader)
 }
 
 ipc___RecordBatchFileReader__num_record_batches <- function(reader){
-    .Call(`_arrow_ipc___RecordBatchFileReader__num_record_batches` , reader)
+    .Call(`_arrow_ipc___RecordBatchFileReader__num_record_batches`, reader)
 }
 
 ipc___RecordBatchFileReader__ReadRecordBatch <- function(reader, i){
-    .Call(`_arrow_ipc___RecordBatchFileReader__ReadRecordBatch` , reader, i)
+    .Call(`_arrow_ipc___RecordBatchFileReader__ReadRecordBatch`, reader, i)
 }
 
 ipc___RecordBatchFileReader__Open <- function(file){
-    .Call(`_arrow_ipc___RecordBatchFileReader__Open` , file)
+    .Call(`_arrow_ipc___RecordBatchFileReader__Open`, file)
 }
 
 Table__from_RecordBatchReader <- function(reader){
-    .Call(`_arrow_Table__from_RecordBatchReader` , reader)
+    .Call(`_arrow_Table__from_RecordBatchReader`, reader)
 }
 
 Table__from_RecordBatchFileReader <- function(reader){
-    .Call(`_arrow_Table__from_RecordBatchFileReader` , reader)
+    .Call(`_arrow_Table__from_RecordBatchFileReader`, reader)
 }
 
 ipc___RecordBatchFileReader__batches <- function(reader){
-    .Call(`_arrow_ipc___RecordBatchFileReader__batches` , reader)
+    .Call(`_arrow_ipc___RecordBatchFileReader__batches`, reader)
 }
 
 ipc___RecordBatchWriter__WriteRecordBatch <- function(batch_writer, batch){
-    invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteRecordBatch` , batch_writer, batch))
+    invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteRecordBatch`, batch_writer, batch))
 }
 
 ipc___RecordBatchWriter__WriteTable <- function(batch_writer, table){
-    invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteTable` , batch_writer, table))
+    invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteTable`, batch_writer, table))
 }
 
 ipc___RecordBatchWriter__Close <- function(batch_writer){
-    invisible(.Call(`_arrow_ipc___RecordBatchWriter__Close` , batch_writer))
+    invisible(.Call(`_arrow_ipc___RecordBatchWriter__Close`, batch_writer))
 }
 
 ipc___RecordBatchFileWriter__Open <- function(stream, schema, use_legacy_format, metadata_version){
-    .Call(`_arrow_ipc___RecordBatchFileWriter__Open` , stream, schema, use_legacy_format, metadata_version)
+    .Call(`_arrow_ipc___RecordBatchFileWriter__Open`, stream, schema, use_legacy_format, metadata_version)
 }
 
 ipc___RecordBatchStreamWriter__Open <- function(stream, schema, use_legacy_format, metadata_version){
-    .Call(`_arrow_ipc___RecordBatchStreamWriter__Open` , stream, schema, use_legacy_format, metadata_version)
+    .Call(`_arrow_ipc___RecordBatchStreamWriter__Open`, stream, schema, use_legacy_format, metadata_version)
 }
 
 Array__GetScalar <- function(x, i){
-    .Call(`_arrow_Array__GetScalar` , x, i)
+    .Call(`_arrow_Array__GetScalar`, x, i)
 }
 
 Scalar__ToString <- function(s){
-    .Call(`_arrow_Scalar__ToString` , s)
+    .Call(`_arrow_Scalar__ToString`, s)
 }
 
 StructScalar__field <- function(s, i){
-    .Call(`_arrow_StructScalar__field` , s, i)
+    .Call(`_arrow_StructScalar__field`, s, i)
 }
 
 StructScalar__GetFieldByName <- function(s, name){
-    .Call(`_arrow_StructScalar__GetFieldByName` , s, name)
+    .Call(`_arrow_StructScalar__GetFieldByName`, s, name)
 }
 
 Scalar__as_vector <- function(scalar){
-    .Call(`_arrow_Scalar__as_vector` , scalar)
+    .Call(`_arrow_Scalar__as_vector`, scalar)
 }
 
 Scalar__is_valid <- function(s){
-    .Call(`_arrow_Scalar__is_valid` , s)
+    .Call(`_arrow_Scalar__is_valid`, s)
 }
 
 Scalar__type <- function(s){
-    .Call(`_arrow_Scalar__type` , s)
+    .Call(`_arrow_Scalar__type`, s)
 }
 
 schema_ <- function(fields){
-    .Call(`_arrow_schema_` , fields)
+    .Call(`_arrow_schema_`, fields)
 }
 
 Schema__ToString <- function(s){
-    .Call(`_arrow_Schema__ToString` , s)
+    .Call(`_arrow_Schema__ToString`, s)
 }
 
 Schema__num_fields <- function(s){
-    .Call(`_arrow_Schema__num_fields` , s)
+    .Call(`_arrow_Schema__num_fields`, s)
 }
 
 Schema__field <- function(s, i){
-    .Call(`_arrow_Schema__field` , s, i)
+    .Call(`_arrow_Schema__field`, s, i)
 }
 
 Schema__GetFieldByName <- function(s, x){
-    .Call(`_arrow_Schema__GetFieldByName` , s, x)
+    .Call(`_arrow_Schema__GetFieldByName`, s, x)
 }
 
 Schema__fields <- function(schema){
-    .Call(`_arrow_Schema__fields` , schema)
+    .Call(`_arrow_Schema__fields`, schema)
 }
 
 Schema__field_names <- function(schema){
-    .Call(`_arrow_Schema__field_names` , schema)
+    .Call(`_arrow_Schema__field_names`, schema)
 }
 
 Schema__HasMetadata <- function(schema){
-    .Call(`_arrow_Schema__HasMetadata` , schema)
+    .Call(`_arrow_Schema__HasMetadata`, schema)
 }
 
 Schema__metadata <- function(schema){
-    .Call(`_arrow_Schema__metadata` , schema)
+    .Call(`_arrow_Schema__metadata`, schema)
 }
 
 Schema__WithMetadata <- function(schema, metadata){
-    .Call(`_arrow_Schema__WithMetadata` , schema, metadata)
+    .Call(`_arrow_Schema__WithMetadata`, schema, metadata)
 }
 
 Schema__serialize <- function(schema){
-    .Call(`_arrow_Schema__serialize` , schema)
+    .Call(`_arrow_Schema__serialize`, schema)
 }
 
 Schema__Equals <- function(schema, other, check_metadata){
-    .Call(`_arrow_Schema__Equals` , schema, other, check_metadata)
+    .Call(`_arrow_Schema__Equals`, schema, other, check_metadata)
 }
 
 arrow__UnifySchemas <- function(schemas){
-    .Call(`_arrow_arrow__UnifySchemas` , schemas)
+    .Call(`_arrow_arrow__UnifySchemas`, schemas)
 }
 
 Table__num_columns <- function(x){
-    .Call(`_arrow_Table__num_columns` , x)
+    .Call(`_arrow_Table__num_columns`, x)
 }
 
 Table__num_rows <- function(x){
-    .Call(`_arrow_Table__num_rows` , x)
+    .Call(`_arrow_Table__num_rows`, x)
 }
 
 Table__schema <- function(x){
-    .Call(`_arrow_Table__schema` , x)
+    .Call(`_arrow_Table__schema`, x)
 }
 
 Table__ReplaceSchemaMetadata <- function(x, metadata){
-    .Call(`_arrow_Table__ReplaceSchemaMetadata` , x, metadata)
+    .Call(`_arrow_Table__ReplaceSchemaMetadata`, x, metadata)
 }
 
 Table__column <- function(table, i){
-    .Call(`_arrow_Table__column` , table, i)
+    .Call(`_arrow_Table__column`, table, i)
 }
 
 Table__field <- function(table, i){
-    .Call(`_arrow_Table__field` , table, i)
+    .Call(`_arrow_Table__field`, table, i)
 }
 
 Table__columns <- function(table){
-    .Call(`_arrow_Table__columns` , table)
+    .Call(`_arrow_Table__columns`, table)
 }
 
 Table__ColumnNames <- function(table){
-    .Call(`_arrow_Table__ColumnNames` , table)
+    .Call(`_arrow_Table__ColumnNames`, table)
 }
 
 Table__RenameColumns <- function(table, names){
-    .Call(`_arrow_Table__RenameColumns` , table, names)
+    .Call(`_arrow_Table__RenameColumns`, table, names)
 }
 
 Table__Slice1 <- function(table, offset){
-    .Call(`_arrow_Table__Slice1` , table, offset)
+    .Call(`_arrow_Table__Slice1`, table, offset)
 }
 
 Table__Slice2 <- function(table, offset, length){
-    .Call(`_arrow_Table__Slice2` , table, offset, length)
+    .Call(`_arrow_Table__Slice2`, table, offset, length)
 }
 
 Table__Equals <- function(lhs, rhs, check_metadata){
-    .Call(`_arrow_Table__Equals` , lhs, rhs, check_metadata)
+    .Call(`_arrow_Table__Equals`, lhs, rhs, check_metadata)
 }
 
 Table__Validate <- function(table){
-    .Call(`_arrow_Table__Validate` , table)
+    .Call(`_arrow_Table__Validate`, table)
 }
 
 Table__ValidateFull <- function(table){
-    .Call(`_arrow_Table__ValidateFull` , table)
+    .Call(`_arrow_Table__ValidateFull`, table)
 }
 
 Table__GetColumnByName <- function(table, name){
-    .Call(`_arrow_Table__GetColumnByName` , table, name)
+    .Call(`_arrow_Table__GetColumnByName`, table, name)
 }
 
 Table__RemoveColumn <- function(table, i){
-    .Call(`_arrow_Table__RemoveColumn` , table, i)
+    .Call(`_arrow_Table__RemoveColumn`, table, i)
 }
 
 Table__AddColumn <- function(table, i, field, column){
-    .Call(`_arrow_Table__AddColumn` , table, i, field, column)
+    .Call(`_arrow_Table__AddColumn`, table, i, field, column)
 }
 
 Table__SetColumn <- function(table, i, field, column){
-    .Call(`_arrow_Table__SetColumn` , table, i, field, column)
+    .Call(`_arrow_Table__SetColumn`, table, i, field, column)
 }
 
 Table__SelectColumns <- function(table, indices){
-    .Call(`_arrow_Table__SelectColumns` , table, indices)
+    .Call(`_arrow_Table__SelectColumns`, table, indices)
 }
 
 all_record_batches <- function(lst){
-    .Call(`_arrow_all_record_batches` , lst)
+    .Call(`_arrow_all_record_batches`, lst)
 }
 
 Table__from_record_batches <- function(batches, schema_sxp){
-    .Call(`_arrow_Table__from_record_batches` , batches, schema_sxp)
+    .Call(`_arrow_Table__from_record_batches`, batches, schema_sxp)
 }
 
 Table__from_dots <- function(lst, schema_sxp){
-    .Call(`_arrow_Table__from_dots` , lst, schema_sxp)
+    .Call(`_arrow_Table__from_dots`, lst, schema_sxp)
 }
 
 GetCpuThreadPoolCapacity <- function(){
-    .Call(`_arrow_GetCpuThreadPoolCapacity` )
+    .Call(`_arrow_GetCpuThreadPoolCapacity`)
 }
 
 SetCpuThreadPoolCapacity <- function(threads){
-    invisible(.Call(`_arrow_SetCpuThreadPoolCapacity` , threads))
+    invisible(.Call(`_arrow_SetCpuThreadPoolCapacity`, threads))
 }
 
 
+
diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R
index 6cd52b4b814..00d7df64140 100644
--- a/r/data-raw/codegen.R
+++ b/r/data-raw/codegen.R
@@ -68,6 +68,20 @@ wrap_call <- function(name, return_type, args) {
   }
 }
 
+write_if_modified <- function(code, file) {
+  old <- try(readLines(file), silent=TRUE)
+  new <- unclass(unlist(strsplit(code, "\n")))
+  # We don't care about changes in empty lines
+  if (!identical(old[nzchar(old)], new[nzchar(new)])) {
+    writeLines(con = file, code)
+    # To debug why they're different if you think they shouldn't be:
+    # print(waldo::compare(old[nzchar(old)], new[nzchar(new)]))
+    message(glue::glue("*** > generated file `{file}`"))
+  } else {
+    message(glue::glue("*** > `{file}` not modified"))
+  }
+}
+
 all_decorations <- cpp_decorations()
 arrow_exports <- get_exported_functions(all_decorations, c("arrow", "s3"))
 
@@ -134,8 +148,7 @@ classes_finalizers_registration <- map2(names(arrow_classes), arrow_classes, fun
   }) %>%
   glue_collapse(sep  = "\n")
 
-
-writeLines(con = "src/arrowExports.cpp", glue::glue('
+arrow_exports_cpp <- glue::glue('
 // Generated by using data-raw/codegen.R -> do not edit by hand
 #include <cpp11.hpp>
 #include <cpp11/declarations.hpp>
@@ -177,10 +190,9 @@ extern "C" void R_init_arrow(DllInfo* dll){{
   R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
   R_useDynamicSymbols(dll, FALSE);
 }}
+\n')
 
-') )
-
-message("*** > generated file `src/arrowExports.cpp`")
+write_if_modified(arrow_exports_cpp, "src/arrowExports.cpp")
 
 r_functions <- arrow_exports %>%
   select(name, return_type, args) %>%
@@ -190,10 +202,9 @@ r_functions <- arrow_exports %>%
     } else {
       ""
     }
-    call <- if(return_type == "void") {
-      glue::glue('invisible(.Call(`_arrow_{name}` {params}))')
-    } else {
-      glue::glue('.Call(`_arrow_{name}` {params})')
+    call <- glue::glue('.Call(`_arrow_{name}`{params})')
+    if (return_type == "void") {
+      call <- glue::glue('invisible({call})')
     }
 
     glue::glue('
@@ -208,10 +219,11 @@ r_functions <- arrow_exports %>%
   }) %>%
   glue_collapse(sep = "\n")
 
-writeLines(con = "R/arrowExports.R", glue::glue('
+arrow_exports_r <- glue::glue('
 # Generated by using data-raw/codegen.R -> do not edit by hand
 
 {r_functions}
 
-'))
-message("*** > generated file `R/arrowExports.R`")
+\n')
+
+write_if_modified(arrow_exports_r, "R/arrowExports.R")

From be93ce73e56dc667fb81c6b7d5d2b1109fdc092f Mon Sep 17 00:00:00 2001
From: Neal Richardson <neal.p.richardson@gmail.com>
Date: Fri, 15 Jan 2021 14:50:12 -0800
Subject: [PATCH 2/4] Further refactoring to prepare for grouping features

---
 r/data-raw/codegen.R | 61 ++++++++++++++++++++++++--------------------
 1 file changed, 34 insertions(+), 27 deletions(-)

diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R
index 00d7df64140..ccc3f3bbdc8 100644
--- a/r/data-raw/codegen.R
+++ b/r/data-raw/codegen.R
@@ -34,6 +34,15 @@
 # }
 # #endif
 
+
+# Different flags can be used to export different features.
+# [[feature::export]]
+# maps to
+# #if defined(ARROW_R_WITH_FEATURE)
+# and each feature is written to its own set of export files.
+
+features <- c("arrow", "s3")
+
 suppressPackageStartupMessages({
   library(decor)
   library(dplyr)
@@ -68,6 +77,20 @@ wrap_call <- function(name, return_type, args) {
   }
 }
 
+feature_available <- function(feat) {
+  glue::glue(
+'extern "C" SEXP _{feat}_available() {{
+return Rf_ScalarLogical(
+#if defined(ARROW_R_WITH_{toupper(feat)})
+  TRUE
+#else
+  FALSE
+#endif
+);
+}}
+')
+}
+
 write_if_modified <- function(code, file) {
   old <- try(readLines(file), silent=TRUE)
   new <- unclass(unlist(strsplit(code, "\n")))
@@ -83,7 +106,7 @@ write_if_modified <- function(code, file) {
 }
 
 all_decorations <- cpp_decorations()
-arrow_exports <- get_exported_functions(all_decorations, c("arrow", "s3"))
+arrow_exports <- get_exported_functions(all_decorations, features)
 
 arrow_classes <- c(
   "Table"   = "arrow::Table",
@@ -123,10 +146,10 @@ cpp_functions_registration <- arrow_exports %>%
   pmap_chr(function(name, return_type, args){
     glue('\t\t{{ "_arrow_{name}", (DL_FUNC) &_arrow_{name}, {nrow(args)}}}, ')
   }) %>%
-  glue_collapse(sep  = "\n")
+  glue_collapse(sep = "\n")
 
 cpp_classes_finalizers <- map2(names(arrow_classes), arrow_classes, function(name, class) {
-  glue::glue('
+  glue('
   # if defined(ARROW_R_WITH_ARROW)
   extern "C" SEXP _arrow_{name}__Reset(SEXP r6) {{
     BEGIN_CPP11
@@ -143,40 +166,24 @@ cpp_classes_finalizers <- map2(names(arrow_classes), arrow_classes, function(nam
 }) %>%
   glue_collapse(sep = "\n")
 
-classes_finalizers_registration <- map2(names(arrow_classes), arrow_classes, function(name, class) {
-    glue('\t\t{{ "_arrow_{name}__Reset", (DL_FUNC) &_arrow_{name}__Reset, 1}}, ')
-  }) %>%
-  glue_collapse(sep  = "\n")
+classes_finalizers_registration <- glue('\t\t{{ "_arrow_{names(arrow_classes)}__Reset", (DL_FUNC) &_arrow_{names(arrow_classes)}__Reset, 1}}, ') %>%
+  glue_collapse(sep = "\n")
 
-arrow_exports_cpp <- glue::glue('
-// Generated by using data-raw/codegen.R -> do not edit by hand
+cpp_file_header <- '// Generated by using data-raw/codegen.R -> do not edit by hand
 #include <cpp11.hpp>
 #include <cpp11/declarations.hpp>
 
 #include "./arrow_types.h"
+'
 
+arrow_exports_cpp <- glue::glue('
+{cpp_file_header}
 {cpp_functions_definitions}
 {cpp_classes_finalizers}
 
-extern "C" SEXP _arrow_available() {{
-return Rf_ScalarLogical(
-#if defined(ARROW_R_WITH_ARROW)
-  TRUE
-#else
-  FALSE
-#endif
-);
-}}
+{feature_available("arrow")}
 
-extern "C" SEXP _s3_available() {{
-return Rf_ScalarLogical(
-#if defined(ARROW_R_WITH_S3)
-  TRUE
-#else
-  FALSE
-#endif
-);
-}}
+{feature_available("s3")}
 
 static const R_CallMethodDef CallEntries[] = {{
 \t\t{{ "_arrow_available", (DL_FUNC)& _arrow_available, 0 }},

From cb6200de28471e3f609b12c706c4455d73c42794 Mon Sep 17 00:00:00 2001
From: Neal Richardson <neal.p.richardson@gmail.com>
Date: Fri, 15 Jan 2021 15:23:46 -0800
Subject: [PATCH 3/4] Further refactoring so that the ifdef wrapping is
 encapsulated

---
 r/data-raw/codegen.R   | 67 ++++++++++++++++++++++++------------------
 r/src/arrowExports.cpp | 38 ++++++++++++------------
 2 files changed, 59 insertions(+), 46 deletions(-)

diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R
index ccc3f3bbdc8..7266f8b2cbf 100644
--- a/r/data-raw/codegen.R
+++ b/r/data-raw/codegen.R
@@ -113,30 +113,46 @@ arrow_classes <- c(
   "RecordBatch" = "arrow::RecordBatch"
 )
 
+# This takes a cpp11 C wrapper and conditionally makes it available based on
+# a feature decoration
+ifdef_wrap <- function(cpp11_wrapped, name, sexp_signature, decoration) {
+  # TODO: uncomment this to remove the arrow-without-arrow wrapping
+  # if (identical(decoration, "arrow")) {
+  #   return(cpp11_wrapped)
+  # }
+  glue('
+  #if defined(ARROW_R_WITH_{toupper(decoration)})
+  {cpp11_wrapped}
+  #else
+  extern "C" SEXP {sexp_signature}{{
+  \tRf_error("Cannot call {name}(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+  }}
+  #endif
+  \n')
+}
+
 cpp_functions_definitions <- arrow_exports %>%
   select(name, return_type, args, file, line, decoration) %>%
-  pmap_chr(function(name, return_type, args, file, line, decoration){
+  pmap_chr(function(name, return_type, args, file, line, decoration) {
+    sexp_params <- glue_collapse_data(args, "SEXP {name}_sexp")
+    sexp_signature <- glue('_arrow_{name}({sexp_params})')
+    cpp11_wrapped <- glue('
+      {return_type} {name}({real_params});
+      extern "C" SEXP {sexp_signature}{{
+      BEGIN_CPP11
+      {input_params}{return_line}{wrap_call(name, return_type, args)}
+      END_CPP11
+      }}',
+      sep = "\n",
+      real_params = glue_collapse_data(args, "{type} {name}"),
+      input_params = glue_collapse_data(args, "\tarrow::r::Input<{type}>::type {name}({name}_sexp);", sep = "\n"),
+      return_line = if(nrow(args)) "\n" else "")
+
     glue::glue('
     // {basename(file)}
-    #if defined(ARROW_R_WITH_{toupper(decoration)})
-    {return_type} {name}({real_params});
-    extern "C" SEXP _arrow_{name}({sexp_params}){{
-    BEGIN_CPP11
-    {input_params}{return_line}{wrap_call(name, return_type, args)}
-    END_CPP11
-    }}
-    #else
-    extern "C" SEXP _arrow_{name}({sexp_params}){{
-    \tRf_error("Cannot call {name}(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-    }}
-    #endif
-
+    {ifdef_wrap(cpp11_wrapped, name, sexp_signature, decoration)}
     ',
       sep = "\n",
-      real_params = glue_collapse_data(args, "{type} {name}"),
-      sexp_params = glue_collapse_data(args, "SEXP {name}_sexp"),
-      input_params = glue_collapse_data(args, "\tarrow::r::Input<{type}>::type {name}({name}_sexp);", sep = "\n"),
-      return_line = if(nrow(args)) "\n" else ""
     )
   }) %>%
   glue_collapse(sep = "\n")
@@ -149,20 +165,15 @@ cpp_functions_registration <- arrow_exports %>%
   glue_collapse(sep = "\n")
 
 cpp_classes_finalizers <- map2(names(arrow_classes), arrow_classes, function(name, class) {
-  glue('
-  # if defined(ARROW_R_WITH_ARROW)
-  extern "C" SEXP _arrow_{name}__Reset(SEXP r6) {{
+  sexp_signature <- glue('_arrow_{name}__Reset(SEXP r6)')
+  cpp11_wrapped <- glue('
+    extern "C" SEXP {sexp_signature} {{
     BEGIN_CPP11
     arrow::r::r6_reset_pointer<{class}>(r6);
     END_CPP11
     return R_NilValue;
-  }}
-  # else
-  extern "C" SEXP _arrow_{name}__Reset(SEXP r6) {{
-    Rf_error("Cannot call _arrow_{name}__Reset(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-  }}
-  # endif
-  ')
+    }}')
+  ifdef_wrap(cpp11_wrapped, name, sexp_signature, "arrow")
 }) %>%
   glue_collapse(sep = "\n")
 
diff --git a/r/src/arrowExports.cpp b/r/src/arrowExports.cpp
index 31aa626e800..82da7f532a0 100644
--- a/r/src/arrowExports.cpp
+++ b/r/src/arrowExports.cpp
@@ -6229,30 +6229,32 @@ extern "C" SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){
 }
 #endif
 
-# if defined(ARROW_R_WITH_ARROW)
+#if defined(ARROW_R_WITH_ARROW)
 extern "C" SEXP _arrow_Table__Reset(SEXP r6) {
-  BEGIN_CPP11
-  arrow::r::r6_reset_pointer<arrow::Table>(r6);
-  END_CPP11
-  return R_NilValue;
+BEGIN_CPP11
+arrow::r::r6_reset_pointer<arrow::Table>(r6);
+END_CPP11
+return R_NilValue;
 }
-# else
-extern "C" SEXP _arrow_Table__Reset(SEXP r6) {
-  Rf_error("Cannot call _arrow_Table__Reset(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+#else
+extern "C" SEXP _arrow_Table__Reset(SEXP r6){
+	Rf_error("Cannot call Table(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
 }
-# endif
-# if defined(ARROW_R_WITH_ARROW)
+#endif
+
+#if defined(ARROW_R_WITH_ARROW)
 extern "C" SEXP _arrow_RecordBatch__Reset(SEXP r6) {
-  BEGIN_CPP11
-  arrow::r::r6_reset_pointer<arrow::RecordBatch>(r6);
-  END_CPP11
-  return R_NilValue;
+BEGIN_CPP11
+arrow::r::r6_reset_pointer<arrow::RecordBatch>(r6);
+END_CPP11
+return R_NilValue;
 }
-# else
-extern "C" SEXP _arrow_RecordBatch__Reset(SEXP r6) {
-  Rf_error("Cannot call _arrow_RecordBatch__Reset(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+#else
+extern "C" SEXP _arrow_RecordBatch__Reset(SEXP r6){
+	Rf_error("Cannot call RecordBatch(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
 }
-# endif
+#endif
+
 
 extern "C" SEXP _arrow_available() {
 return Rf_ScalarLogical(

From 2e8115d9f7432c3751b1db7424b2e458cc314712 Mon Sep 17 00:00:00 2001
From: Neal Richardson <neal.p.richardson@gmail.com>
Date: Fri, 15 Jan 2021 17:18:18 -0800
Subject: [PATCH 4/4] Remove arrow-without-arrow wrapping in arrowExports.cpp

---
 r/data-raw/codegen.R   |    8 +-
 r/src/arrowExports.cpp | 2795 +---------------------------------------
 2 files changed, 12 insertions(+), 2791 deletions(-)

diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R
index 7266f8b2cbf..a287569a53b 100644
--- a/r/data-raw/codegen.R
+++ b/r/data-raw/codegen.R
@@ -116,10 +116,10 @@ arrow_classes <- c(
 # This takes a cpp11 C wrapper and conditionally makes it available based on
 # a feature decoration
 ifdef_wrap <- function(cpp11_wrapped, name, sexp_signature, decoration) {
-  # TODO: uncomment this to remove the arrow-without-arrow wrapping
-  # if (identical(decoration, "arrow")) {
-  #   return(cpp11_wrapped)
-  # }
+  if (identical(decoration, "arrow")) {
+    # Arrow is now required
+    return(cpp11_wrapped)
+  }
   glue('
   #if defined(ARROW_R_WITH_{toupper(decoration)})
   {cpp11_wrapped}
diff --git a/r/src/arrowExports.cpp b/r/src/arrowExports.cpp
index 82da7f532a0..c78085be831 100644
--- a/r/src/arrowExports.cpp
+++ b/r/src/arrowExports.cpp
@@ -5,7 +5,6 @@
 #include "./arrow_types.h"
 
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> Array__Slice1(const std::shared_ptr<arrow::Array>& array, R_xlen_t offset);
 extern "C" SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){
 BEGIN_CPP11
@@ -14,14 +13,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__Slice1(array, offset));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){
-	Rf_error("Cannot call Array__Slice1(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> Array__Slice2(const std::shared_ptr<arrow::Array>& array, R_xlen_t offset, R_xlen_t length);
 extern "C" SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){
 BEGIN_CPP11
@@ -31,14 +23,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__Slice2(array, offset, length));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){
-	Rf_error("Cannot call Array__Slice2(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Array__IsNull(const std::shared_ptr<arrow::Array>& x, R_xlen_t i);
 extern "C" SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -47,14 +32,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__IsNull(x, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){
-	Rf_error("Cannot call Array__IsNull(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Array__IsValid(const std::shared_ptr<arrow::Array>& x, R_xlen_t i);
 extern "C" SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -63,14 +41,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__IsValid(x, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){
-	Rf_error("Cannot call Array__IsValid(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int Array__length(const std::shared_ptr<arrow::Array>& x);
 extern "C" SEXP _arrow_Array__length(SEXP x_sexp){
 BEGIN_CPP11
@@ -78,14 +49,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__length(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__length(SEXP x_sexp){
-	Rf_error("Cannot call Array__length(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int Array__offset(const std::shared_ptr<arrow::Array>& x);
 extern "C" SEXP _arrow_Array__offset(SEXP x_sexp){
 BEGIN_CPP11
@@ -93,14 +57,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__offset(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__offset(SEXP x_sexp){
-	Rf_error("Cannot call Array__offset(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int Array__null_count(const std::shared_ptr<arrow::Array>& x);
 extern "C" SEXP _arrow_Array__null_count(SEXP x_sexp){
 BEGIN_CPP11
@@ -108,14 +65,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__null_count(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__null_count(SEXP x_sexp){
-	Rf_error("Cannot call Array__null_count(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Array__type(const std::shared_ptr<arrow::Array>& x);
 extern "C" SEXP _arrow_Array__type(SEXP x_sexp){
 BEGIN_CPP11
@@ -123,14 +73,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__type(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__type(SEXP x_sexp){
-	Rf_error("Cannot call Array__type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string Array__ToString(const std::shared_ptr<arrow::Array>& x);
 extern "C" SEXP _arrow_Array__ToString(SEXP x_sexp){
 BEGIN_CPP11
@@ -138,14 +81,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__ToString(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__ToString(SEXP x_sexp){
-	Rf_error("Cannot call Array__ToString(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 arrow::Type::type Array__type_id(const std::shared_ptr<arrow::Array>& x);
 extern "C" SEXP _arrow_Array__type_id(SEXP x_sexp){
 BEGIN_CPP11
@@ -153,14 +89,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__type_id(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__type_id(SEXP x_sexp){
-	Rf_error("Cannot call Array__type_id(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Array__Equals(const std::shared_ptr<arrow::Array>& lhs, const std::shared_ptr<arrow::Array>& rhs);
 extern "C" SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){
 BEGIN_CPP11
@@ -169,14 +98,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__Equals(lhs, rhs));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){
-	Rf_error("Cannot call Array__Equals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Array__ApproxEquals(const std::shared_ptr<arrow::Array>& lhs, const std::shared_ptr<arrow::Array>& rhs);
 extern "C" SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){
 BEGIN_CPP11
@@ -185,14 +107,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__ApproxEquals(lhs, rhs));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){
-	Rf_error("Cannot call Array__ApproxEquals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ArrayData> Array__data(const std::shared_ptr<arrow::Array>& array);
 extern "C" SEXP _arrow_Array__data(SEXP array_sexp){
 BEGIN_CPP11
@@ -200,14 +115,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__data(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__data(SEXP array_sexp){
-	Rf_error("Cannot call Array__data(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Array__RangeEquals(const std::shared_ptr<arrow::Array>& self, const std::shared_ptr<arrow::Array>& other, R_xlen_t start_idx, R_xlen_t end_idx, R_xlen_t other_start_idx);
 extern "C" SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){
 BEGIN_CPP11
@@ -219,14 +127,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__RangeEquals(self, other, start_idx, end_idx, other_start_idx));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){
-	Rf_error("Cannot call Array__RangeEquals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> Array__View(const std::shared_ptr<arrow::Array>& array, const std::shared_ptr<arrow::DataType>& type);
 extern "C" SEXP _arrow_Array__View(SEXP array_sexp, SEXP type_sexp){
 BEGIN_CPP11
@@ -235,14 +136,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__View(array, type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__View(SEXP array_sexp, SEXP type_sexp){
-	Rf_error("Cannot call Array__View(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void Array__Validate(const std::shared_ptr<arrow::Array>& array);
 extern "C" SEXP _arrow_Array__Validate(SEXP array_sexp){
 BEGIN_CPP11
@@ -251,14 +145,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__Validate(SEXP array_sexp){
-	Rf_error("Cannot call Array__Validate(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> DictionaryArray__indices(const std::shared_ptr<arrow::DictionaryArray>& array);
 extern "C" SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){
 BEGIN_CPP11
@@ -266,14 +153,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DictionaryArray__indices(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){
-	Rf_error("Cannot call DictionaryArray__indices(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> DictionaryArray__dictionary(const std::shared_ptr<arrow::DictionaryArray>& array);
 extern "C" SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){
 BEGIN_CPP11
@@ -281,14 +161,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DictionaryArray__dictionary(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){
-	Rf_error("Cannot call DictionaryArray__dictionary(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> StructArray__field(const std::shared_ptr<arrow::StructArray>& array, int i);
 extern "C" SEXP _arrow_StructArray__field(SEXP array_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -297,14 +170,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(StructArray__field(array, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_StructArray__field(SEXP array_sexp, SEXP i_sexp){
-	Rf_error("Cannot call StructArray__field(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> StructArray__GetFieldByName(const std::shared_ptr<arrow::StructArray>& array, const std::string& name);
 extern "C" SEXP _arrow_StructArray__GetFieldByName(SEXP array_sexp, SEXP name_sexp){
 BEGIN_CPP11
@@ -313,14 +179,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(StructArray__GetFieldByName(array, name));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_StructArray__GetFieldByName(SEXP array_sexp, SEXP name_sexp){
-	Rf_error("Cannot call StructArray__GetFieldByName(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list StructArray__Flatten(const std::shared_ptr<arrow::StructArray>& array);
 extern "C" SEXP _arrow_StructArray__Flatten(SEXP array_sexp){
 BEGIN_CPP11
@@ -328,14 +187,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(StructArray__Flatten(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_StructArray__Flatten(SEXP array_sexp){
-	Rf_error("Cannot call StructArray__Flatten(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> ListArray__value_type(const std::shared_ptr<arrow::ListArray>& array);
 extern "C" SEXP _arrow_ListArray__value_type(SEXP array_sexp){
 BEGIN_CPP11
@@ -343,14 +195,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ListArray__value_type(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ListArray__value_type(SEXP array_sexp){
-	Rf_error("Cannot call ListArray__value_type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> LargeListArray__value_type(const std::shared_ptr<arrow::LargeListArray>& array);
 extern "C" SEXP _arrow_LargeListArray__value_type(SEXP array_sexp){
 BEGIN_CPP11
@@ -358,14 +203,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(LargeListArray__value_type(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_LargeListArray__value_type(SEXP array_sexp){
-	Rf_error("Cannot call LargeListArray__value_type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> ListArray__values(const std::shared_ptr<arrow::ListArray>& array);
 extern "C" SEXP _arrow_ListArray__values(SEXP array_sexp){
 BEGIN_CPP11
@@ -373,14 +211,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ListArray__values(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ListArray__values(SEXP array_sexp){
-	Rf_error("Cannot call ListArray__values(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> LargeListArray__values(const std::shared_ptr<arrow::LargeListArray>& array);
 extern "C" SEXP _arrow_LargeListArray__values(SEXP array_sexp){
 BEGIN_CPP11
@@ -388,14 +219,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(LargeListArray__values(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_LargeListArray__values(SEXP array_sexp){
-	Rf_error("Cannot call LargeListArray__values(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int32_t ListArray__value_length(const std::shared_ptr<arrow::ListArray>& array, int64_t i);
 extern "C" SEXP _arrow_ListArray__value_length(SEXP array_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -404,14 +228,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ListArray__value_length(array, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ListArray__value_length(SEXP array_sexp, SEXP i_sexp){
-	Rf_error("Cannot call ListArray__value_length(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t LargeListArray__value_length(const std::shared_ptr<arrow::LargeListArray>& array, int64_t i);
 extern "C" SEXP _arrow_LargeListArray__value_length(SEXP array_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -420,14 +237,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(LargeListArray__value_length(array, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_LargeListArray__value_length(SEXP array_sexp, SEXP i_sexp){
-	Rf_error("Cannot call LargeListArray__value_length(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t FixedSizeListArray__value_length(const std::shared_ptr<arrow::FixedSizeListArray>& array, int64_t i);
 extern "C" SEXP _arrow_FixedSizeListArray__value_length(SEXP array_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -436,14 +246,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(FixedSizeListArray__value_length(array, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_FixedSizeListArray__value_length(SEXP array_sexp, SEXP i_sexp){
-	Rf_error("Cannot call FixedSizeListArray__value_length(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int32_t ListArray__value_offset(const std::shared_ptr<arrow::ListArray>& array, int64_t i);
 extern "C" SEXP _arrow_ListArray__value_offset(SEXP array_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -452,14 +255,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ListArray__value_offset(array, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ListArray__value_offset(SEXP array_sexp, SEXP i_sexp){
-	Rf_error("Cannot call ListArray__value_offset(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t LargeListArray__value_offset(const std::shared_ptr<arrow::LargeListArray>& array, int64_t i);
 extern "C" SEXP _arrow_LargeListArray__value_offset(SEXP array_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -468,14 +264,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(LargeListArray__value_offset(array, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_LargeListArray__value_offset(SEXP array_sexp, SEXP i_sexp){
-	Rf_error("Cannot call LargeListArray__value_offset(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t FixedSizeListArray__value_offset(const std::shared_ptr<arrow::FixedSizeListArray>& array, int64_t i);
 extern "C" SEXP _arrow_FixedSizeListArray__value_offset(SEXP array_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -484,14 +273,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(FixedSizeListArray__value_offset(array, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_FixedSizeListArray__value_offset(SEXP array_sexp, SEXP i_sexp){
-	Rf_error("Cannot call FixedSizeListArray__value_offset(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::writable::integers ListArray__raw_value_offsets(const std::shared_ptr<arrow::ListArray>& array);
 extern "C" SEXP _arrow_ListArray__raw_value_offsets(SEXP array_sexp){
 BEGIN_CPP11
@@ -499,14 +281,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ListArray__raw_value_offsets(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ListArray__raw_value_offsets(SEXP array_sexp){
-	Rf_error("Cannot call ListArray__raw_value_offsets(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::writable::integers LargeListArray__raw_value_offsets(const std::shared_ptr<arrow::LargeListArray>& array);
 extern "C" SEXP _arrow_LargeListArray__raw_value_offsets(SEXP array_sexp){
 BEGIN_CPP11
@@ -514,14 +289,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(LargeListArray__raw_value_offsets(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_LargeListArray__raw_value_offsets(SEXP array_sexp){
-	Rf_error("Cannot call LargeListArray__raw_value_offsets(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array_from_vector.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Array__infer_type(SEXP x);
 extern "C" SEXP _arrow_Array__infer_type(SEXP x_sexp){
 BEGIN_CPP11
@@ -529,14 +297,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__infer_type(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__infer_type(SEXP x_sexp){
-	Rf_error("Cannot call Array__infer_type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array_from_vector.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> Array__from_vector(SEXP x, SEXP s_type);
 extern "C" SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){
 BEGIN_CPP11
@@ -545,14 +306,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__from_vector(x, s_type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){
-	Rf_error("Cannot call Array__from_vector(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array_from_vector.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ChunkedArray> ChunkedArray__from_list(cpp11::list chunks, SEXP s_type);
 extern "C" SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){
 BEGIN_CPP11
@@ -561,14 +315,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__from_list(chunks, s_type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){
-	Rf_error("Cannot call ChunkedArray__from_list(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array_from_vector.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> DictionaryArray__FromArrays(const std::shared_ptr<arrow::DataType>& type, const std::shared_ptr<arrow::Array>& indices, const std::shared_ptr<arrow::Array>& dict);
 extern "C" SEXP _arrow_DictionaryArray__FromArrays(SEXP type_sexp, SEXP indices_sexp, SEXP dict_sexp){
 BEGIN_CPP11
@@ -578,14 +325,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DictionaryArray__FromArrays(type, indices, dict));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DictionaryArray__FromArrays(SEXP type_sexp, SEXP indices_sexp, SEXP dict_sexp){
-	Rf_error("Cannot call DictionaryArray__FromArrays(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array_to_vector.cpp
-#if defined(ARROW_R_WITH_ARROW)
 SEXP Array__as_vector(const std::shared_ptr<arrow::Array>& array);
 extern "C" SEXP _arrow_Array__as_vector(SEXP array_sexp){
 BEGIN_CPP11
@@ -593,14 +333,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__as_vector(array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__as_vector(SEXP array_sexp){
-	Rf_error("Cannot call Array__as_vector(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array_to_vector.cpp
-#if defined(ARROW_R_WITH_ARROW)
 SEXP ChunkedArray__as_vector(const std::shared_ptr<arrow::ChunkedArray>& chunked_array);
 extern "C" SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){
 BEGIN_CPP11
@@ -608,14 +341,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__as_vector(chunked_array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){
-	Rf_error("Cannot call ChunkedArray__as_vector(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array_to_vector.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::writable::list RecordBatch__to_dataframe(const std::shared_ptr<arrow::RecordBatch>& batch, bool use_threads);
 extern "C" SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){
 BEGIN_CPP11
@@ -624,14 +350,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__to_dataframe(batch, use_threads));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){
-	Rf_error("Cannot call RecordBatch__to_dataframe(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // array_to_vector.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::writable::list Table__to_dataframe(const std::shared_ptr<arrow::Table>& table, bool use_threads);
 extern "C" SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){
 BEGIN_CPP11
@@ -640,14 +359,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__to_dataframe(table, use_threads));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){
-	Rf_error("Cannot call Table__to_dataframe(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // arraydata.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> ArrayData__get_type(const std::shared_ptr<arrow::ArrayData>& x);
 extern "C" SEXP _arrow_ArrayData__get_type(SEXP x_sexp){
 BEGIN_CPP11
@@ -655,14 +367,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ArrayData__get_type(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ArrayData__get_type(SEXP x_sexp){
-	Rf_error("Cannot call ArrayData__get_type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // arraydata.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int ArrayData__get_length(const std::shared_ptr<arrow::ArrayData>& x);
 extern "C" SEXP _arrow_ArrayData__get_length(SEXP x_sexp){
 BEGIN_CPP11
@@ -670,14 +375,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ArrayData__get_length(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ArrayData__get_length(SEXP x_sexp){
-	Rf_error("Cannot call ArrayData__get_length(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // arraydata.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int ArrayData__get_null_count(const std::shared_ptr<arrow::ArrayData>& x);
 extern "C" SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){
 BEGIN_CPP11
@@ -685,14 +383,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ArrayData__get_null_count(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){
-	Rf_error("Cannot call ArrayData__get_null_count(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // arraydata.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int ArrayData__get_offset(const std::shared_ptr<arrow::ArrayData>& x);
 extern "C" SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){
 BEGIN_CPP11
@@ -700,14 +391,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ArrayData__get_offset(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){
-	Rf_error("Cannot call ArrayData__get_offset(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // arraydata.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list ArrayData__buffers(const std::shared_ptr<arrow::ArrayData>& x);
 extern "C" SEXP _arrow_ArrayData__buffers(SEXP x_sexp){
 BEGIN_CPP11
@@ -715,14 +399,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ArrayData__buffers(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ArrayData__buffers(SEXP x_sexp){
-	Rf_error("Cannot call ArrayData__buffers(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // buffer.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Buffer__is_mutable(const std::shared_ptr<arrow::Buffer>& buffer);
 extern "C" SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){
 BEGIN_CPP11
@@ -730,14 +407,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Buffer__is_mutable(buffer));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){
-	Rf_error("Cannot call Buffer__is_mutable(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // buffer.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void Buffer__ZeroPadding(const std::shared_ptr<arrow::Buffer>& buffer);
 extern "C" SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){
 BEGIN_CPP11
@@ -746,14 +416,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){
-	Rf_error("Cannot call Buffer__ZeroPadding(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // buffer.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t Buffer__capacity(const std::shared_ptr<arrow::Buffer>& buffer);
 extern "C" SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){
 BEGIN_CPP11
@@ -761,14 +424,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Buffer__capacity(buffer));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){
-	Rf_error("Cannot call Buffer__capacity(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // buffer.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t Buffer__size(const std::shared_ptr<arrow::Buffer>& buffer);
 extern "C" SEXP _arrow_Buffer__size(SEXP buffer_sexp){
 BEGIN_CPP11
@@ -776,14 +432,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Buffer__size(buffer));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Buffer__size(SEXP buffer_sexp){
-	Rf_error("Cannot call Buffer__size(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // buffer.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Buffer> r___RBuffer__initialize(SEXP x);
 extern "C" SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){
 BEGIN_CPP11
@@ -791,14 +440,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(r___RBuffer__initialize(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){
-	Rf_error("Cannot call r___RBuffer__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // buffer.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::writable::raws Buffer__data(const std::shared_ptr<arrow::Buffer>& buffer);
 extern "C" SEXP _arrow_Buffer__data(SEXP buffer_sexp){
 BEGIN_CPP11
@@ -806,14 +448,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Buffer__data(buffer));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Buffer__data(SEXP buffer_sexp){
-	Rf_error("Cannot call Buffer__data(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // buffer.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Buffer__Equals(const std::shared_ptr<arrow::Buffer>& x, const std::shared_ptr<arrow::Buffer>& y);
 extern "C" SEXP _arrow_Buffer__Equals(SEXP x_sexp, SEXP y_sexp){
 BEGIN_CPP11
@@ -822,14 +457,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Buffer__Equals(x, y));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Buffer__Equals(SEXP x_sexp, SEXP y_sexp){
-	Rf_error("Cannot call Buffer__Equals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int ChunkedArray__length(const std::shared_ptr<arrow::ChunkedArray>& chunked_array);
 extern "C" SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){
 BEGIN_CPP11
@@ -837,14 +465,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__length(chunked_array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){
-	Rf_error("Cannot call ChunkedArray__length(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int ChunkedArray__null_count(const std::shared_ptr<arrow::ChunkedArray>& chunked_array);
 extern "C" SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){
 BEGIN_CPP11
@@ -852,14 +473,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__null_count(chunked_array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){
-	Rf_error("Cannot call ChunkedArray__null_count(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int ChunkedArray__num_chunks(const std::shared_ptr<arrow::ChunkedArray>& chunked_array);
 extern "C" SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){
 BEGIN_CPP11
@@ -867,14 +481,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__num_chunks(chunked_array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){
-	Rf_error("Cannot call ChunkedArray__num_chunks(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> ChunkedArray__chunk(const std::shared_ptr<arrow::ChunkedArray>& chunked_array, int i);
 extern "C" SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -883,14 +490,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__chunk(chunked_array, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){
-	Rf_error("Cannot call ChunkedArray__chunk(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list ChunkedArray__chunks(const std::shared_ptr<arrow::ChunkedArray>& chunked_array);
 extern "C" SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){
 BEGIN_CPP11
@@ -898,14 +498,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__chunks(chunked_array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){
-	Rf_error("Cannot call ChunkedArray__chunks(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> ChunkedArray__type(const std::shared_ptr<arrow::ChunkedArray>& chunked_array);
 extern "C" SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){
 BEGIN_CPP11
@@ -913,14 +506,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__type(chunked_array));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){
-	Rf_error("Cannot call ChunkedArray__type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ChunkedArray> ChunkedArray__Slice1(const std::shared_ptr<arrow::ChunkedArray>& chunked_array, R_xlen_t offset);
 extern "C" SEXP _arrow_ChunkedArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){
 BEGIN_CPP11
@@ -929,14 +515,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__Slice1(chunked_array, offset));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){
-	Rf_error("Cannot call ChunkedArray__Slice1(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ChunkedArray> ChunkedArray__Slice2(const std::shared_ptr<arrow::ChunkedArray>& chunked_array, R_xlen_t offset, R_xlen_t length);
 extern "C" SEXP _arrow_ChunkedArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){
 BEGIN_CPP11
@@ -946,14 +525,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__Slice2(chunked_array, offset, length));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){
-	Rf_error("Cannot call ChunkedArray__Slice2(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ChunkedArray> ChunkedArray__View(const std::shared_ptr<arrow::ChunkedArray>& array, const std::shared_ptr<arrow::DataType>& type);
 extern "C" SEXP _arrow_ChunkedArray__View(SEXP array_sexp, SEXP type_sexp){
 BEGIN_CPP11
@@ -962,14 +534,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__View(array, type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__View(SEXP array_sexp, SEXP type_sexp){
-	Rf_error("Cannot call ChunkedArray__View(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void ChunkedArray__Validate(const std::shared_ptr<arrow::ChunkedArray>& chunked_array);
 extern "C" SEXP _arrow_ChunkedArray__Validate(SEXP chunked_array_sexp){
 BEGIN_CPP11
@@ -978,14 +543,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__Validate(SEXP chunked_array_sexp){
-	Rf_error("Cannot call ChunkedArray__Validate(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool ChunkedArray__Equals(const std::shared_ptr<arrow::ChunkedArray>& x, const std::shared_ptr<arrow::ChunkedArray>& y);
 extern "C" SEXP _arrow_ChunkedArray__Equals(SEXP x_sexp, SEXP y_sexp){
 BEGIN_CPP11
@@ -994,14 +552,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__Equals(x, y));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__Equals(SEXP x_sexp, SEXP y_sexp){
-	Rf_error("Cannot call ChunkedArray__Equals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // chunkedarray.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string ChunkedArray__ToString(const std::shared_ptr<arrow::ChunkedArray>& x);
 extern "C" SEXP _arrow_ChunkedArray__ToString(SEXP x_sexp){
 BEGIN_CPP11
@@ -1009,14 +560,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__ToString(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__ToString(SEXP x_sexp){
-	Rf_error("Cannot call ChunkedArray__ToString(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compression.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::util::Codec> util___Codec__Create(arrow::Compression::type codec, R_xlen_t compression_level);
 extern "C" SEXP _arrow_util___Codec__Create(SEXP codec_sexp, SEXP compression_level_sexp){
 BEGIN_CPP11
@@ -1025,14 +569,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(util___Codec__Create(codec, compression_level));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_util___Codec__Create(SEXP codec_sexp, SEXP compression_level_sexp){
-	Rf_error("Cannot call util___Codec__Create(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compression.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string util___Codec__name(const std::shared_ptr<arrow::util::Codec>& codec);
 extern "C" SEXP _arrow_util___Codec__name(SEXP codec_sexp){
 BEGIN_CPP11
@@ -1040,14 +577,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(util___Codec__name(codec));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_util___Codec__name(SEXP codec_sexp){
-	Rf_error("Cannot call util___Codec__name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compression.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool util___Codec__IsAvailable(arrow::Compression::type codec);
 extern "C" SEXP _arrow_util___Codec__IsAvailable(SEXP codec_sexp){
 BEGIN_CPP11
@@ -1055,14 +585,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(util___Codec__IsAvailable(codec));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_util___Codec__IsAvailable(SEXP codec_sexp){
-	Rf_error("Cannot call util___Codec__IsAvailable(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compression.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::CompressedOutputStream> io___CompressedOutputStream__Make(const std::shared_ptr<arrow::util::Codec>& codec, const std::shared_ptr<arrow::io::OutputStream>& raw);
 extern "C" SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){
 BEGIN_CPP11
@@ -1071,14 +594,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___CompressedOutputStream__Make(codec, raw));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){
-	Rf_error("Cannot call io___CompressedOutputStream__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compression.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::CompressedInputStream> io___CompressedInputStream__Make(const std::shared_ptr<arrow::util::Codec>& codec, const std::shared_ptr<arrow::io::InputStream>& raw);
 extern "C" SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){
 BEGIN_CPP11
@@ -1087,14 +603,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___CompressedInputStream__Make(codec, raw));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){
-	Rf_error("Cannot call io___CompressedInputStream__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compute.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::compute::CastOptions> compute___CastOptions__initialize(bool allow_int_overflow, bool allow_time_truncate, bool allow_float_truncate);
 extern "C" SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){
 BEGIN_CPP11
@@ -1104,14 +613,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(compute___CastOptions__initialize(allow_int_overflow, allow_time_truncate, allow_float_truncate));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){
-	Rf_error("Cannot call compute___CastOptions__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compute.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> Array__cast(const std::shared_ptr<arrow::Array>& array, const std::shared_ptr<arrow::DataType>& target_type, const std::shared_ptr<arrow::compute::CastOptions>& options);
 extern "C" SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){
 BEGIN_CPP11
@@ -1121,14 +623,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__cast(array, target_type, options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){
-	Rf_error("Cannot call Array__cast(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compute.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ChunkedArray> ChunkedArray__cast(const std::shared_ptr<arrow::ChunkedArray>& chunked_array, const std::shared_ptr<arrow::DataType>& target_type, const std::shared_ptr<arrow::compute::CastOptions>& options);
 extern "C" SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){
 BEGIN_CPP11
@@ -1138,14 +633,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ChunkedArray__cast(chunked_array, target_type, options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){
-	Rf_error("Cannot call ChunkedArray__cast(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compute.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> RecordBatch__cast(const std::shared_ptr<arrow::RecordBatch>& batch, const std::shared_ptr<arrow::Schema>& schema, const std::shared_ptr<arrow::compute::CastOptions>& options);
 extern "C" SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){
 BEGIN_CPP11
@@ -1155,14 +643,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__cast(batch, schema, options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){
-	Rf_error("Cannot call RecordBatch__cast(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compute.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__cast(const std::shared_ptr<arrow::Table>& table, const std::shared_ptr<arrow::Schema>& schema, const std::shared_ptr<arrow::compute::CastOptions>& options);
 extern "C" SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){
 BEGIN_CPP11
@@ -1172,14 +653,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__cast(table, schema, options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){
-	Rf_error("Cannot call Table__cast(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // compute.cpp
-#if defined(ARROW_R_WITH_ARROW)
 SEXP compute__CallFunction(std::string func_name, cpp11::list args, cpp11::list options);
 extern "C" SEXP _arrow_compute__CallFunction(SEXP func_name_sexp, SEXP args_sexp, SEXP options_sexp){
 BEGIN_CPP11
@@ -1189,14 +663,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(compute__CallFunction(func_name, args, options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_compute__CallFunction(SEXP func_name_sexp, SEXP args_sexp, SEXP options_sexp){
-	Rf_error("Cannot call compute__CallFunction(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // csv.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::csv::ReadOptions> csv___ReadOptions__initialize(cpp11::list options);
 extern "C" SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){
 BEGIN_CPP11
@@ -1204,14 +671,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(csv___ReadOptions__initialize(options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){
-	Rf_error("Cannot call csv___ReadOptions__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // csv.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::csv::ParseOptions> csv___ParseOptions__initialize(cpp11::list options);
 extern "C" SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){
 BEGIN_CPP11
@@ -1219,14 +679,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(csv___ParseOptions__initialize(options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){
-	Rf_error("Cannot call csv___ParseOptions__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // csv.cpp
-#if defined(ARROW_R_WITH_ARROW)
 SEXP csv___ReadOptions__column_names(const std::shared_ptr<arrow::csv::ReadOptions>& options);
 extern "C" SEXP _arrow_csv___ReadOptions__column_names(SEXP options_sexp){
 BEGIN_CPP11
@@ -1234,14 +687,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(csv___ReadOptions__column_names(options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_csv___ReadOptions__column_names(SEXP options_sexp){
-	Rf_error("Cannot call csv___ReadOptions__column_names(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // csv.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::csv::ConvertOptions> csv___ConvertOptions__initialize(cpp11::list options);
 extern "C" SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){
 BEGIN_CPP11
@@ -1249,14 +695,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(csv___ConvertOptions__initialize(options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){
-	Rf_error("Cannot call csv___ConvertOptions__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // csv.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::csv::TableReader> csv___TableReader__Make(const std::shared_ptr<arrow::io::InputStream>& input, const std::shared_ptr<arrow::csv::ReadOptions>& read_options, const std::shared_ptr<arrow::csv::ParseOptions>& parse_options, const std::shared_ptr<arrow::csv::ConvertOptions>& convert_options);
 extern "C" SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){
 BEGIN_CPP11
@@ -1267,14 +706,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(csv___TableReader__Make(input, read_options, parse_options, convert_options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){
-	Rf_error("Cannot call csv___TableReader__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // csv.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> csv___TableReader__Read(const std::shared_ptr<arrow::csv::TableReader>& table_reader);
 extern "C" SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){
 BEGIN_CPP11
@@ -1282,14 +714,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(csv___TableReader__Read(table_reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){
-	Rf_error("Cannot call csv___TableReader__Read(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // csv.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string TimestampParser__kind(const std::shared_ptr<arrow::TimestampParser>& parser);
 extern "C" SEXP _arrow_TimestampParser__kind(SEXP parser_sexp){
 BEGIN_CPP11
@@ -1297,14 +722,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(TimestampParser__kind(parser));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_TimestampParser__kind(SEXP parser_sexp){
-	Rf_error("Cannot call TimestampParser__kind(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // csv.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string TimestampParser__format(const std::shared_ptr<arrow::TimestampParser>& parser);
 extern "C" SEXP _arrow_TimestampParser__format(SEXP parser_sexp){
 BEGIN_CPP11
@@ -1312,14 +730,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(TimestampParser__format(parser));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_TimestampParser__format(SEXP parser_sexp){
-	Rf_error("Cannot call TimestampParser__format(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // csv.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::TimestampParser> TimestampParser__MakeStrptime(std::string format);
 extern "C" SEXP _arrow_TimestampParser__MakeStrptime(SEXP format_sexp){
 BEGIN_CPP11
@@ -1327,28 +738,14 @@ BEGIN_CPP11
 	return cpp11::as_sexp(TimestampParser__MakeStrptime(format));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_TimestampParser__MakeStrptime(SEXP format_sexp){
-	Rf_error("Cannot call TimestampParser__MakeStrptime(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // csv.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::TimestampParser> TimestampParser__MakeISO8601();
 extern "C" SEXP _arrow_TimestampParser__MakeISO8601(){
 BEGIN_CPP11
 	return cpp11::as_sexp(TimestampParser__MakeISO8601());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_TimestampParser__MakeISO8601(){
-	Rf_error("Cannot call TimestampParser__MakeISO8601(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::ScannerBuilder> dataset___Dataset__NewScan(const std::shared_ptr<ds::Dataset>& ds);
 extern "C" SEXP _arrow_dataset___Dataset__NewScan(SEXP ds_sexp){
 BEGIN_CPP11
@@ -1356,14 +753,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___Dataset__NewScan(ds));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___Dataset__NewScan(SEXP ds_sexp){
-	Rf_error("Cannot call dataset___Dataset__NewScan(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> dataset___Dataset__schema(const std::shared_ptr<ds::Dataset>& dataset);
 extern "C" SEXP _arrow_dataset___Dataset__schema(SEXP dataset_sexp){
 BEGIN_CPP11
@@ -1371,14 +761,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___Dataset__schema(dataset));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___Dataset__schema(SEXP dataset_sexp){
-	Rf_error("Cannot call dataset___Dataset__schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string dataset___Dataset__type_name(const std::shared_ptr<ds::Dataset>& dataset);
 extern "C" SEXP _arrow_dataset___Dataset__type_name(SEXP dataset_sexp){
 BEGIN_CPP11
@@ -1386,14 +769,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___Dataset__type_name(dataset));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___Dataset__type_name(SEXP dataset_sexp){
-	Rf_error("Cannot call dataset___Dataset__type_name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::Dataset> dataset___Dataset__ReplaceSchema(const std::shared_ptr<ds::Dataset>& dataset, const std::shared_ptr<arrow::Schema>& schm);
 extern "C" SEXP _arrow_dataset___Dataset__ReplaceSchema(SEXP dataset_sexp, SEXP schm_sexp){
 BEGIN_CPP11
@@ -1402,14 +778,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___Dataset__ReplaceSchema(dataset, schm));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___Dataset__ReplaceSchema(SEXP dataset_sexp, SEXP schm_sexp){
-	Rf_error("Cannot call dataset___Dataset__ReplaceSchema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::Dataset> dataset___UnionDataset__create(const ds::DatasetVector& datasets, const std::shared_ptr<arrow::Schema>& schm);
 extern "C" SEXP _arrow_dataset___UnionDataset__create(SEXP datasets_sexp, SEXP schm_sexp){
 BEGIN_CPP11
@@ -1418,14 +787,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___UnionDataset__create(datasets, schm));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___UnionDataset__create(SEXP datasets_sexp, SEXP schm_sexp){
-	Rf_error("Cannot call dataset___UnionDataset__create(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::Dataset> dataset___InMemoryDataset__create(const std::shared_ptr<arrow::Table>& table);
 extern "C" SEXP _arrow_dataset___InMemoryDataset__create(SEXP table_sexp){
 BEGIN_CPP11
@@ -1433,14 +795,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___InMemoryDataset__create(table));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___InMemoryDataset__create(SEXP table_sexp){
-	Rf_error("Cannot call dataset___InMemoryDataset__create(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list dataset___UnionDataset__children(const std::shared_ptr<ds::UnionDataset>& ds);
 extern "C" SEXP _arrow_dataset___UnionDataset__children(SEXP ds_sexp){
 BEGIN_CPP11
@@ -1448,14 +803,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___UnionDataset__children(ds));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___UnionDataset__children(SEXP ds_sexp){
-	Rf_error("Cannot call dataset___UnionDataset__children(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::FileFormat> dataset___FileSystemDataset__format(const std::shared_ptr<ds::FileSystemDataset>& dataset);
 extern "C" SEXP _arrow_dataset___FileSystemDataset__format(SEXP dataset_sexp){
 BEGIN_CPP11
@@ -1463,14 +811,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___FileSystemDataset__format(dataset));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___FileSystemDataset__format(SEXP dataset_sexp){
-	Rf_error("Cannot call dataset___FileSystemDataset__format(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<fs::FileSystem> dataset___FileSystemDataset__filesystem(const std::shared_ptr<ds::FileSystemDataset>& dataset);
 extern "C" SEXP _arrow_dataset___FileSystemDataset__filesystem(SEXP dataset_sexp){
 BEGIN_CPP11
@@ -1478,14 +819,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___FileSystemDataset__filesystem(dataset));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___FileSystemDataset__filesystem(SEXP dataset_sexp){
-	Rf_error("Cannot call dataset___FileSystemDataset__filesystem(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::vector<std::string> dataset___FileSystemDataset__files(const std::shared_ptr<ds::FileSystemDataset>& dataset);
 extern "C" SEXP _arrow_dataset___FileSystemDataset__files(SEXP dataset_sexp){
 BEGIN_CPP11
@@ -1493,14 +827,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___FileSystemDataset__files(dataset));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___FileSystemDataset__files(SEXP dataset_sexp){
-	Rf_error("Cannot call dataset___FileSystemDataset__files(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::Dataset> dataset___DatasetFactory__Finish1(const std::shared_ptr<ds::DatasetFactory>& factory, bool unify_schemas);
 extern "C" SEXP _arrow_dataset___DatasetFactory__Finish1(SEXP factory_sexp, SEXP unify_schemas_sexp){
 BEGIN_CPP11
@@ -1509,14 +836,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___DatasetFactory__Finish1(factory, unify_schemas));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___DatasetFactory__Finish1(SEXP factory_sexp, SEXP unify_schemas_sexp){
-	Rf_error("Cannot call dataset___DatasetFactory__Finish1(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::Dataset> dataset___DatasetFactory__Finish2(const std::shared_ptr<ds::DatasetFactory>& factory, const std::shared_ptr<arrow::Schema>& schema);
 extern "C" SEXP _arrow_dataset___DatasetFactory__Finish2(SEXP factory_sexp, SEXP schema_sexp){
 BEGIN_CPP11
@@ -1525,14 +845,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___DatasetFactory__Finish2(factory, schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___DatasetFactory__Finish2(SEXP factory_sexp, SEXP schema_sexp){
-	Rf_error("Cannot call dataset___DatasetFactory__Finish2(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> dataset___DatasetFactory__Inspect(const std::shared_ptr<ds::DatasetFactory>& factory, bool unify_schemas);
 extern "C" SEXP _arrow_dataset___DatasetFactory__Inspect(SEXP factory_sexp, SEXP unify_schemas_sexp){
 BEGIN_CPP11
@@ -1541,14 +854,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___DatasetFactory__Inspect(factory, unify_schemas));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___DatasetFactory__Inspect(SEXP factory_sexp, SEXP unify_schemas_sexp){
-	Rf_error("Cannot call dataset___DatasetFactory__Inspect(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::DatasetFactory> dataset___UnionDatasetFactory__Make(const std::vector<std::shared_ptr<ds::DatasetFactory>>& children);
 extern "C" SEXP _arrow_dataset___UnionDatasetFactory__Make(SEXP children_sexp){
 BEGIN_CPP11
@@ -1556,14 +862,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___UnionDatasetFactory__Make(children));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___UnionDatasetFactory__Make(SEXP children_sexp){
-	Rf_error("Cannot call dataset___UnionDatasetFactory__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::FileSystemDatasetFactory> dataset___FileSystemDatasetFactory__Make2(const std::shared_ptr<fs::FileSystem>& fs, const std::shared_ptr<fs::FileSelector>& selector, const std::shared_ptr<ds::FileFormat>& format, const std::shared_ptr<ds::Partitioning>& partitioning);
 extern "C" SEXP _arrow_dataset___FileSystemDatasetFactory__Make2(SEXP fs_sexp, SEXP selector_sexp, SEXP format_sexp, SEXP partitioning_sexp){
 BEGIN_CPP11
@@ -1574,14 +873,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___FileSystemDatasetFactory__Make2(fs, selector, format, partitioning));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___FileSystemDatasetFactory__Make2(SEXP fs_sexp, SEXP selector_sexp, SEXP format_sexp, SEXP partitioning_sexp){
-	Rf_error("Cannot call dataset___FileSystemDatasetFactory__Make2(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::FileSystemDatasetFactory> dataset___FileSystemDatasetFactory__Make1(const std::shared_ptr<fs::FileSystem>& fs, const std::shared_ptr<fs::FileSelector>& selector, const std::shared_ptr<ds::FileFormat>& format);
 extern "C" SEXP _arrow_dataset___FileSystemDatasetFactory__Make1(SEXP fs_sexp, SEXP selector_sexp, SEXP format_sexp){
 BEGIN_CPP11
@@ -1591,14 +883,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___FileSystemDatasetFactory__Make1(fs, selector, format));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___FileSystemDatasetFactory__Make1(SEXP fs_sexp, SEXP selector_sexp, SEXP format_sexp){
-	Rf_error("Cannot call dataset___FileSystemDatasetFactory__Make1(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::FileSystemDatasetFactory> dataset___FileSystemDatasetFactory__Make3(const std::shared_ptr<fs::FileSystem>& fs, const std::shared_ptr<fs::FileSelector>& selector, const std::shared_ptr<ds::FileFormat>& format, const std::shared_ptr<ds::PartitioningFactory>& factory);
 extern "C" SEXP _arrow_dataset___FileSystemDatasetFactory__Make3(SEXP fs_sexp, SEXP selector_sexp, SEXP format_sexp, SEXP factory_sexp){
 BEGIN_CPP11
@@ -1609,14 +894,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___FileSystemDatasetFactory__Make3(fs, selector, format, factory));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___FileSystemDatasetFactory__Make3(SEXP fs_sexp, SEXP selector_sexp, SEXP format_sexp, SEXP factory_sexp){
-	Rf_error("Cannot call dataset___FileSystemDatasetFactory__Make3(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string dataset___FileFormat__type_name(const std::shared_ptr<ds::FileFormat>& format);
 extern "C" SEXP _arrow_dataset___FileFormat__type_name(SEXP format_sexp){
 BEGIN_CPP11
@@ -1624,14 +902,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___FileFormat__type_name(format));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___FileFormat__type_name(SEXP format_sexp){
-	Rf_error("Cannot call dataset___FileFormat__type_name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::FileWriteOptions> dataset___FileFormat__DefaultWriteOptions(const std::shared_ptr<ds::FileFormat>& fmt);
 extern "C" SEXP _arrow_dataset___FileFormat__DefaultWriteOptions(SEXP fmt_sexp){
 BEGIN_CPP11
@@ -1639,14 +910,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___FileFormat__DefaultWriteOptions(fmt));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___FileFormat__DefaultWriteOptions(SEXP fmt_sexp){
-	Rf_error("Cannot call dataset___FileFormat__DefaultWriteOptions(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::ParquetFileFormat> dataset___ParquetFileFormat__Make(bool use_buffered_stream, int64_t buffer_size, cpp11::strings dict_columns);
 extern "C" SEXP _arrow_dataset___ParquetFileFormat__Make(SEXP use_buffered_stream_sexp, SEXP buffer_size_sexp, SEXP dict_columns_sexp){
 BEGIN_CPP11
@@ -1656,14 +920,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___ParquetFileFormat__Make(use_buffered_stream, buffer_size, dict_columns));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___ParquetFileFormat__Make(SEXP use_buffered_stream_sexp, SEXP buffer_size_sexp, SEXP dict_columns_sexp){
-	Rf_error("Cannot call dataset___ParquetFileFormat__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string dataset___FileWriteOptions__type_name(const std::shared_ptr<ds::FileWriteOptions>& options);
 extern "C" SEXP _arrow_dataset___FileWriteOptions__type_name(SEXP options_sexp){
 BEGIN_CPP11
@@ -1671,14 +928,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___FileWriteOptions__type_name(options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___FileWriteOptions__type_name(SEXP options_sexp){
-	Rf_error("Cannot call dataset___FileWriteOptions__type_name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void dataset___ParquetFileWriteOptions__update(const std::shared_ptr<ds::ParquetFileWriteOptions>& options, const std::shared_ptr<parquet::WriterProperties>& writer_props, const std::shared_ptr<parquet::ArrowWriterProperties>& arrow_writer_props);
 extern "C" SEXP _arrow_dataset___ParquetFileWriteOptions__update(SEXP options_sexp, SEXP writer_props_sexp, SEXP arrow_writer_props_sexp){
 BEGIN_CPP11
@@ -1689,14 +939,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___ParquetFileWriteOptions__update(SEXP options_sexp, SEXP writer_props_sexp, SEXP arrow_writer_props_sexp){
-	Rf_error("Cannot call dataset___ParquetFileWriteOptions__update(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void dataset___IpcFileWriteOptions__update2(const std::shared_ptr<ds::IpcFileWriteOptions>& ipc_options, bool use_legacy_format, const std::shared_ptr<arrow::util::Codec>& codec, arrow::ipc::MetadataVersion metadata_version);
 extern "C" SEXP _arrow_dataset___IpcFileWriteOptions__update2(SEXP ipc_options_sexp, SEXP use_legacy_format_sexp, SEXP codec_sexp, SEXP metadata_version_sexp){
 BEGIN_CPP11
@@ -1708,14 +951,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___IpcFileWriteOptions__update2(SEXP ipc_options_sexp, SEXP use_legacy_format_sexp, SEXP codec_sexp, SEXP metadata_version_sexp){
-	Rf_error("Cannot call dataset___IpcFileWriteOptions__update2(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void dataset___IpcFileWriteOptions__update1(const std::shared_ptr<ds::IpcFileWriteOptions>& ipc_options, bool use_legacy_format, arrow::ipc::MetadataVersion metadata_version);
 extern "C" SEXP _arrow_dataset___IpcFileWriteOptions__update1(SEXP ipc_options_sexp, SEXP use_legacy_format_sexp, SEXP metadata_version_sexp){
 BEGIN_CPP11
@@ -1726,28 +962,14 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___IpcFileWriteOptions__update1(SEXP ipc_options_sexp, SEXP use_legacy_format_sexp, SEXP metadata_version_sexp){
-	Rf_error("Cannot call dataset___IpcFileWriteOptions__update1(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::IpcFileFormat> dataset___IpcFileFormat__Make();
 extern "C" SEXP _arrow_dataset___IpcFileFormat__Make(){
 BEGIN_CPP11
 	return cpp11::as_sexp(dataset___IpcFileFormat__Make());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___IpcFileFormat__Make(){
-	Rf_error("Cannot call dataset___IpcFileFormat__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::CsvFileFormat> dataset___CsvFileFormat__Make(const std::shared_ptr<arrow::csv::ParseOptions>& parse_options);
 extern "C" SEXP _arrow_dataset___CsvFileFormat__Make(SEXP parse_options_sexp){
 BEGIN_CPP11
@@ -1755,14 +977,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___CsvFileFormat__Make(parse_options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___CsvFileFormat__Make(SEXP parse_options_sexp){
-	Rf_error("Cannot call dataset___CsvFileFormat__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::DirectoryPartitioning> dataset___DirectoryPartitioning(const std::shared_ptr<arrow::Schema>& schm);
 extern "C" SEXP _arrow_dataset___DirectoryPartitioning(SEXP schm_sexp){
 BEGIN_CPP11
@@ -1770,14 +985,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___DirectoryPartitioning(schm));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___DirectoryPartitioning(SEXP schm_sexp){
-	Rf_error("Cannot call dataset___DirectoryPartitioning(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::PartitioningFactory> dataset___DirectoryPartitioning__MakeFactory(const std::vector<std::string>& field_names);
 extern "C" SEXP _arrow_dataset___DirectoryPartitioning__MakeFactory(SEXP field_names_sexp){
 BEGIN_CPP11
@@ -1785,14 +993,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___DirectoryPartitioning__MakeFactory(field_names));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___DirectoryPartitioning__MakeFactory(SEXP field_names_sexp){
-	Rf_error("Cannot call dataset___DirectoryPartitioning__MakeFactory(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::HivePartitioning> dataset___HivePartitioning(const std::shared_ptr<arrow::Schema>& schm);
 extern "C" SEXP _arrow_dataset___HivePartitioning(SEXP schm_sexp){
 BEGIN_CPP11
@@ -1800,28 +1001,14 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___HivePartitioning(schm));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___HivePartitioning(SEXP schm_sexp){
-	Rf_error("Cannot call dataset___HivePartitioning(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::PartitioningFactory> dataset___HivePartitioning__MakeFactory();
 extern "C" SEXP _arrow_dataset___HivePartitioning__MakeFactory(){
 BEGIN_CPP11
 	return cpp11::as_sexp(dataset___HivePartitioning__MakeFactory());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___HivePartitioning__MakeFactory(){
-	Rf_error("Cannot call dataset___HivePartitioning__MakeFactory(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void dataset___ScannerBuilder__Project(const std::shared_ptr<ds::ScannerBuilder>& sb, const std::vector<std::string>& cols);
 extern "C" SEXP _arrow_dataset___ScannerBuilder__Project(SEXP sb_sexp, SEXP cols_sexp){
 BEGIN_CPP11
@@ -1831,14 +1018,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___ScannerBuilder__Project(SEXP sb_sexp, SEXP cols_sexp){
-	Rf_error("Cannot call dataset___ScannerBuilder__Project(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void dataset___ScannerBuilder__Filter(const std::shared_ptr<ds::ScannerBuilder>& sb, const std::shared_ptr<ds::Expression>& expr);
 extern "C" SEXP _arrow_dataset___ScannerBuilder__Filter(SEXP sb_sexp, SEXP expr_sexp){
 BEGIN_CPP11
@@ -1848,14 +1028,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___ScannerBuilder__Filter(SEXP sb_sexp, SEXP expr_sexp){
-	Rf_error("Cannot call dataset___ScannerBuilder__Filter(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void dataset___ScannerBuilder__UseThreads(const std::shared_ptr<ds::ScannerBuilder>& sb, bool threads);
 extern "C" SEXP _arrow_dataset___ScannerBuilder__UseThreads(SEXP sb_sexp, SEXP threads_sexp){
 BEGIN_CPP11
@@ -1865,14 +1038,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___ScannerBuilder__UseThreads(SEXP sb_sexp, SEXP threads_sexp){
-	Rf_error("Cannot call dataset___ScannerBuilder__UseThreads(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void dataset___ScannerBuilder__BatchSize(const std::shared_ptr<ds::ScannerBuilder>& sb, int64_t batch_size);
 extern "C" SEXP _arrow_dataset___ScannerBuilder__BatchSize(SEXP sb_sexp, SEXP batch_size_sexp){
 BEGIN_CPP11
@@ -1882,14 +1048,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___ScannerBuilder__BatchSize(SEXP sb_sexp, SEXP batch_size_sexp){
-	Rf_error("Cannot call dataset___ScannerBuilder__BatchSize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> dataset___ScannerBuilder__schema(const std::shared_ptr<ds::ScannerBuilder>& sb);
 extern "C" SEXP _arrow_dataset___ScannerBuilder__schema(SEXP sb_sexp){
 BEGIN_CPP11
@@ -1897,14 +1056,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___ScannerBuilder__schema(sb));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___ScannerBuilder__schema(SEXP sb_sexp){
-	Rf_error("Cannot call dataset___ScannerBuilder__schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::Scanner> dataset___ScannerBuilder__Finish(const std::shared_ptr<ds::ScannerBuilder>& sb);
 extern "C" SEXP _arrow_dataset___ScannerBuilder__Finish(SEXP sb_sexp){
 BEGIN_CPP11
@@ -1912,14 +1064,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___ScannerBuilder__Finish(sb));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___ScannerBuilder__Finish(SEXP sb_sexp){
-	Rf_error("Cannot call dataset___ScannerBuilder__Finish(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> dataset___Scanner__ToTable(const std::shared_ptr<ds::Scanner>& scanner);
 extern "C" SEXP _arrow_dataset___Scanner__ToTable(SEXP scanner_sexp){
 BEGIN_CPP11
@@ -1927,14 +1072,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___Scanner__ToTable(scanner));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___Scanner__ToTable(SEXP scanner_sexp){
-	Rf_error("Cannot call dataset___Scanner__ToTable(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> dataset___Scanner__head(const std::shared_ptr<ds::Scanner>& scanner, int n);
 extern "C" SEXP _arrow_dataset___Scanner__head(SEXP scanner_sexp, SEXP n_sexp){
 BEGIN_CPP11
@@ -1943,14 +1081,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___Scanner__head(scanner, n));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___Scanner__head(SEXP scanner_sexp, SEXP n_sexp){
-	Rf_error("Cannot call dataset___Scanner__head(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list dataset___Scanner__Scan(const std::shared_ptr<ds::Scanner>& scanner);
 extern "C" SEXP _arrow_dataset___Scanner__Scan(SEXP scanner_sexp){
 BEGIN_CPP11
@@ -1958,14 +1089,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___Scanner__Scan(scanner));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___Scanner__Scan(SEXP scanner_sexp){
-	Rf_error("Cannot call dataset___Scanner__Scan(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> dataset___Scanner__schema(const std::shared_ptr<ds::Scanner>& sc);
 extern "C" SEXP _arrow_dataset___Scanner__schema(SEXP sc_sexp){
 BEGIN_CPP11
@@ -1973,14 +1097,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___Scanner__schema(sc));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___Scanner__schema(SEXP sc_sexp){
-	Rf_error("Cannot call dataset___Scanner__schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list dataset___ScanTask__get_batches(const std::shared_ptr<ds::ScanTask>& scan_task);
 extern "C" SEXP _arrow_dataset___ScanTask__get_batches(SEXP scan_task_sexp){
 BEGIN_CPP11
@@ -1988,14 +1105,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___ScanTask__get_batches(scan_task));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___ScanTask__get_batches(SEXP scan_task_sexp){
-	Rf_error("Cannot call dataset___ScanTask__get_batches(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // dataset.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void dataset___Dataset__Write(const std::shared_ptr<ds::FileWriteOptions>& file_write_options, const std::shared_ptr<fs::FileSystem>& filesystem, std::string base_dir, const std::shared_ptr<ds::Partitioning>& partitioning, std::string basename_template, const std::shared_ptr<ds::Scanner>& scanner);
 extern "C" SEXP _arrow_dataset___Dataset__Write(SEXP file_write_options_sexp, SEXP filesystem_sexp, SEXP base_dir_sexp, SEXP partitioning_sexp, SEXP basename_template_sexp, SEXP scanner_sexp){
 BEGIN_CPP11
@@ -2009,280 +1119,140 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___Dataset__Write(SEXP file_write_options_sexp, SEXP filesystem_sexp, SEXP base_dir_sexp, SEXP partitioning_sexp, SEXP basename_template_sexp, SEXP scanner_sexp){
-	Rf_error("Cannot call dataset___Dataset__Write(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Int8__initialize();
 extern "C" SEXP _arrow_Int8__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Int8__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Int8__initialize(){
-	Rf_error("Cannot call Int8__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Int16__initialize();
 extern "C" SEXP _arrow_Int16__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Int16__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Int16__initialize(){
-	Rf_error("Cannot call Int16__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Int32__initialize();
 extern "C" SEXP _arrow_Int32__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Int32__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Int32__initialize(){
-	Rf_error("Cannot call Int32__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Int64__initialize();
 extern "C" SEXP _arrow_Int64__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Int64__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Int64__initialize(){
-	Rf_error("Cannot call Int64__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> UInt8__initialize();
 extern "C" SEXP _arrow_UInt8__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(UInt8__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_UInt8__initialize(){
-	Rf_error("Cannot call UInt8__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> UInt16__initialize();
 extern "C" SEXP _arrow_UInt16__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(UInt16__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_UInt16__initialize(){
-	Rf_error("Cannot call UInt16__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> UInt32__initialize();
 extern "C" SEXP _arrow_UInt32__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(UInt32__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_UInt32__initialize(){
-	Rf_error("Cannot call UInt32__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> UInt64__initialize();
 extern "C" SEXP _arrow_UInt64__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(UInt64__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_UInt64__initialize(){
-	Rf_error("Cannot call UInt64__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Float16__initialize();
 extern "C" SEXP _arrow_Float16__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Float16__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Float16__initialize(){
-	Rf_error("Cannot call Float16__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Float32__initialize();
 extern "C" SEXP _arrow_Float32__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Float32__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Float32__initialize(){
-	Rf_error("Cannot call Float32__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Float64__initialize();
 extern "C" SEXP _arrow_Float64__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Float64__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Float64__initialize(){
-	Rf_error("Cannot call Float64__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Boolean__initialize();
 extern "C" SEXP _arrow_Boolean__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Boolean__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Boolean__initialize(){
-	Rf_error("Cannot call Boolean__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Utf8__initialize();
 extern "C" SEXP _arrow_Utf8__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Utf8__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Utf8__initialize(){
-	Rf_error("Cannot call Utf8__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> LargeUtf8__initialize();
 extern "C" SEXP _arrow_LargeUtf8__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(LargeUtf8__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_LargeUtf8__initialize(){
-	Rf_error("Cannot call LargeUtf8__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Binary__initialize();
 extern "C" SEXP _arrow_Binary__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Binary__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Binary__initialize(){
-	Rf_error("Cannot call Binary__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> LargeBinary__initialize();
 extern "C" SEXP _arrow_LargeBinary__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(LargeBinary__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_LargeBinary__initialize(){
-	Rf_error("Cannot call LargeBinary__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Date32__initialize();
 extern "C" SEXP _arrow_Date32__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Date32__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Date32__initialize(){
-	Rf_error("Cannot call Date32__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Date64__initialize();
 extern "C" SEXP _arrow_Date64__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Date64__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Date64__initialize(){
-	Rf_error("Cannot call Date64__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Null__initialize();
 extern "C" SEXP _arrow_Null__initialize(){
 BEGIN_CPP11
 	return cpp11::as_sexp(Null__initialize());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Null__initialize(){
-	Rf_error("Cannot call Null__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Decimal128Type__initialize(int32_t precision, int32_t scale);
 extern "C" SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){
 BEGIN_CPP11
@@ -2291,14 +1261,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Decimal128Type__initialize(precision, scale));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){
-	Rf_error("Cannot call Decimal128Type__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> FixedSizeBinary__initialize(R_xlen_t byte_width);
 extern "C" SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){
 BEGIN_CPP11
@@ -2306,14 +1269,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(FixedSizeBinary__initialize(byte_width));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){
-	Rf_error("Cannot call FixedSizeBinary__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Timestamp__initialize(arrow::TimeUnit::type unit, const std::string& timezone);
 extern "C" SEXP _arrow_Timestamp__initialize(SEXP unit_sexp, SEXP timezone_sexp){
 BEGIN_CPP11
@@ -2322,14 +1278,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Timestamp__initialize(unit, timezone));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Timestamp__initialize(SEXP unit_sexp, SEXP timezone_sexp){
-	Rf_error("Cannot call Timestamp__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Time32__initialize(arrow::TimeUnit::type unit);
 extern "C" SEXP _arrow_Time32__initialize(SEXP unit_sexp){
 BEGIN_CPP11
@@ -2337,14 +1286,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Time32__initialize(unit));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Time32__initialize(SEXP unit_sexp){
-	Rf_error("Cannot call Time32__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Time64__initialize(arrow::TimeUnit::type unit);
 extern "C" SEXP _arrow_Time64__initialize(SEXP unit_sexp){
 BEGIN_CPP11
@@ -2352,14 +1294,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Time64__initialize(unit));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Time64__initialize(SEXP unit_sexp){
-	Rf_error("Cannot call Time64__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> list__(SEXP x);
 extern "C" SEXP _arrow_list__(SEXP x_sexp){
 BEGIN_CPP11
@@ -2367,14 +1302,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(list__(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_list__(SEXP x_sexp){
-	Rf_error("Cannot call list__(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> large_list__(SEXP x);
 extern "C" SEXP _arrow_large_list__(SEXP x_sexp){
 BEGIN_CPP11
@@ -2382,14 +1310,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(large_list__(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_large_list__(SEXP x_sexp){
-	Rf_error("Cannot call large_list__(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> fixed_size_list__(SEXP x, int list_size);
 extern "C" SEXP _arrow_fixed_size_list__(SEXP x_sexp, SEXP list_size_sexp){
 BEGIN_CPP11
@@ -2398,14 +1319,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fixed_size_list__(x, list_size));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fixed_size_list__(SEXP x_sexp, SEXP list_size_sexp){
-	Rf_error("Cannot call fixed_size_list__(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> struct__(const std::vector<std::shared_ptr<arrow::Field>>& fields);
 extern "C" SEXP _arrow_struct__(SEXP fields_sexp){
 BEGIN_CPP11
@@ -2413,14 +1327,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(struct__(fields));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_struct__(SEXP fields_sexp){
-	Rf_error("Cannot call struct__(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string DataType__ToString(const std::shared_ptr<arrow::DataType>& type);
 extern "C" SEXP _arrow_DataType__ToString(SEXP type_sexp){
 BEGIN_CPP11
@@ -2428,14 +1335,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DataType__ToString(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DataType__ToString(SEXP type_sexp){
-	Rf_error("Cannot call DataType__ToString(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string DataType__name(const std::shared_ptr<arrow::DataType>& type);
 extern "C" SEXP _arrow_DataType__name(SEXP type_sexp){
 BEGIN_CPP11
@@ -2443,14 +1343,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DataType__name(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DataType__name(SEXP type_sexp){
-	Rf_error("Cannot call DataType__name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool DataType__Equals(const std::shared_ptr<arrow::DataType>& lhs, const std::shared_ptr<arrow::DataType>& rhs);
 extern "C" SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){
 BEGIN_CPP11
@@ -2459,14 +1352,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DataType__Equals(lhs, rhs));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){
-	Rf_error("Cannot call DataType__Equals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int DataType__num_fields(const std::shared_ptr<arrow::DataType>& type);
 extern "C" SEXP _arrow_DataType__num_fields(SEXP type_sexp){
 BEGIN_CPP11
@@ -2474,14 +1360,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DataType__num_fields(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DataType__num_fields(SEXP type_sexp){
-	Rf_error("Cannot call DataType__num_fields(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list DataType__fields(const std::shared_ptr<arrow::DataType>& type);
 extern "C" SEXP _arrow_DataType__fields(SEXP type_sexp){
 BEGIN_CPP11
@@ -2489,14 +1368,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DataType__fields(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DataType__fields(SEXP type_sexp){
-	Rf_error("Cannot call DataType__fields(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 arrow::Type::type DataType__id(const std::shared_ptr<arrow::DataType>& type);
 extern "C" SEXP _arrow_DataType__id(SEXP type_sexp){
 BEGIN_CPP11
@@ -2504,14 +1376,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DataType__id(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DataType__id(SEXP type_sexp){
-	Rf_error("Cannot call DataType__id(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string ListType__ToString(const std::shared_ptr<arrow::ListType>& type);
 extern "C" SEXP _arrow_ListType__ToString(SEXP type_sexp){
 BEGIN_CPP11
@@ -2519,14 +1384,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ListType__ToString(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ListType__ToString(SEXP type_sexp){
-	Rf_error("Cannot call ListType__ToString(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int FixedWidthType__bit_width(const std::shared_ptr<arrow::FixedWidthType>& type);
 extern "C" SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){
 BEGIN_CPP11
@@ -2534,14 +1392,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(FixedWidthType__bit_width(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){
-	Rf_error("Cannot call FixedWidthType__bit_width(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 arrow::DateUnit DateType__unit(const std::shared_ptr<arrow::DateType>& type);
 extern "C" SEXP _arrow_DateType__unit(SEXP type_sexp){
 BEGIN_CPP11
@@ -2549,14 +1400,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DateType__unit(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DateType__unit(SEXP type_sexp){
-	Rf_error("Cannot call DateType__unit(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 arrow::TimeUnit::type TimeType__unit(const std::shared_ptr<arrow::TimeType>& type);
 extern "C" SEXP _arrow_TimeType__unit(SEXP type_sexp){
 BEGIN_CPP11
@@ -2564,14 +1408,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(TimeType__unit(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_TimeType__unit(SEXP type_sexp){
-	Rf_error("Cannot call TimeType__unit(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int32_t DecimalType__precision(const std::shared_ptr<arrow::DecimalType>& type);
 extern "C" SEXP _arrow_DecimalType__precision(SEXP type_sexp){
 BEGIN_CPP11
@@ -2579,14 +1416,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DecimalType__precision(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DecimalType__precision(SEXP type_sexp){
-	Rf_error("Cannot call DecimalType__precision(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int32_t DecimalType__scale(const std::shared_ptr<arrow::DecimalType>& type);
 extern "C" SEXP _arrow_DecimalType__scale(SEXP type_sexp){
 BEGIN_CPP11
@@ -2594,14 +1424,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DecimalType__scale(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DecimalType__scale(SEXP type_sexp){
-	Rf_error("Cannot call DecimalType__scale(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string TimestampType__timezone(const std::shared_ptr<arrow::TimestampType>& type);
 extern "C" SEXP _arrow_TimestampType__timezone(SEXP type_sexp){
 BEGIN_CPP11
@@ -2609,14 +1432,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(TimestampType__timezone(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_TimestampType__timezone(SEXP type_sexp){
-	Rf_error("Cannot call TimestampType__timezone(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 arrow::TimeUnit::type TimestampType__unit(const std::shared_ptr<arrow::TimestampType>& type);
 extern "C" SEXP _arrow_TimestampType__unit(SEXP type_sexp){
 BEGIN_CPP11
@@ -2624,14 +1440,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(TimestampType__unit(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_TimestampType__unit(SEXP type_sexp){
-	Rf_error("Cannot call TimestampType__unit(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> DictionaryType__initialize(const std::shared_ptr<arrow::DataType>& index_type, const std::shared_ptr<arrow::DataType>& value_type, bool ordered);
 extern "C" SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){
 BEGIN_CPP11
@@ -2641,14 +1450,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DictionaryType__initialize(index_type, value_type, ordered));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){
-	Rf_error("Cannot call DictionaryType__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> DictionaryType__index_type(const std::shared_ptr<arrow::DictionaryType>& type);
 extern "C" SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){
 BEGIN_CPP11
@@ -2656,14 +1458,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DictionaryType__index_type(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){
-	Rf_error("Cannot call DictionaryType__index_type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> DictionaryType__value_type(const std::shared_ptr<arrow::DictionaryType>& type);
 extern "C" SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){
 BEGIN_CPP11
@@ -2671,14 +1466,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DictionaryType__value_type(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){
-	Rf_error("Cannot call DictionaryType__value_type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string DictionaryType__name(const std::shared_ptr<arrow::DictionaryType>& type);
 extern "C" SEXP _arrow_DictionaryType__name(SEXP type_sexp){
 BEGIN_CPP11
@@ -2686,14 +1474,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DictionaryType__name(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DictionaryType__name(SEXP type_sexp){
-	Rf_error("Cannot call DictionaryType__name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool DictionaryType__ordered(const std::shared_ptr<arrow::DictionaryType>& type);
 extern "C" SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){
 BEGIN_CPP11
@@ -2701,14 +1482,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(DictionaryType__ordered(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){
-	Rf_error("Cannot call DictionaryType__ordered(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Field> StructType__GetFieldByName(const std::shared_ptr<arrow::StructType>& type, const std::string& name);
 extern "C" SEXP _arrow_StructType__GetFieldByName(SEXP type_sexp, SEXP name_sexp){
 BEGIN_CPP11
@@ -2717,14 +1491,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(StructType__GetFieldByName(type, name));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_StructType__GetFieldByName(SEXP type_sexp, SEXP name_sexp){
-	Rf_error("Cannot call StructType__GetFieldByName(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int StructType__GetFieldIndex(const std::shared_ptr<arrow::StructType>& type, const std::string& name);
 extern "C" SEXP _arrow_StructType__GetFieldIndex(SEXP type_sexp, SEXP name_sexp){
 BEGIN_CPP11
@@ -2733,14 +1500,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(StructType__GetFieldIndex(type, name));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_StructType__GetFieldIndex(SEXP type_sexp, SEXP name_sexp){
-	Rf_error("Cannot call StructType__GetFieldIndex(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Field> ListType__value_field(const std::shared_ptr<arrow::ListType>& type);
 extern "C" SEXP _arrow_ListType__value_field(SEXP type_sexp){
 BEGIN_CPP11
@@ -2748,14 +1508,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ListType__value_field(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ListType__value_field(SEXP type_sexp){
-	Rf_error("Cannot call ListType__value_field(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> ListType__value_type(const std::shared_ptr<arrow::ListType>& type);
 extern "C" SEXP _arrow_ListType__value_type(SEXP type_sexp){
 BEGIN_CPP11
@@ -2763,14 +1516,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ListType__value_type(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ListType__value_type(SEXP type_sexp){
-	Rf_error("Cannot call ListType__value_type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Field> LargeListType__value_field(const std::shared_ptr<arrow::LargeListType>& type);
 extern "C" SEXP _arrow_LargeListType__value_field(SEXP type_sexp){
 BEGIN_CPP11
@@ -2778,14 +1524,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(LargeListType__value_field(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_LargeListType__value_field(SEXP type_sexp){
-	Rf_error("Cannot call LargeListType__value_field(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> LargeListType__value_type(const std::shared_ptr<arrow::LargeListType>& type);
 extern "C" SEXP _arrow_LargeListType__value_type(SEXP type_sexp){
 BEGIN_CPP11
@@ -2793,14 +1532,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(LargeListType__value_type(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_LargeListType__value_type(SEXP type_sexp){
-	Rf_error("Cannot call LargeListType__value_type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Field> FixedSizeListType__value_field(const std::shared_ptr<arrow::FixedSizeListType>& type);
 extern "C" SEXP _arrow_FixedSizeListType__value_field(SEXP type_sexp){
 BEGIN_CPP11
@@ -2808,14 +1540,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(FixedSizeListType__value_field(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_FixedSizeListType__value_field(SEXP type_sexp){
-	Rf_error("Cannot call FixedSizeListType__value_field(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> FixedSizeListType__value_type(const std::shared_ptr<arrow::FixedSizeListType>& type);
 extern "C" SEXP _arrow_FixedSizeListType__value_type(SEXP type_sexp){
 BEGIN_CPP11
@@ -2823,14 +1548,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(FixedSizeListType__value_type(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_FixedSizeListType__value_type(SEXP type_sexp){
-	Rf_error("Cannot call FixedSizeListType__value_type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // datatype.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int FixedSizeListType__list_size(const std::shared_ptr<arrow::FixedSizeListType>& type);
 extern "C" SEXP _arrow_FixedSizeListType__list_size(SEXP type_sexp){
 BEGIN_CPP11
@@ -2838,14 +1556,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(FixedSizeListType__list_size(type));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_FixedSizeListType__list_size(SEXP type_sexp){
-	Rf_error("Cannot call FixedSizeListType__list_size(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // expression.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::Expression> dataset___expr__call(std::string func_name, cpp11::list argument_list, cpp11::list options);
 extern "C" SEXP _arrow_dataset___expr__call(SEXP func_name_sexp, SEXP argument_list_sexp, SEXP options_sexp){
 BEGIN_CPP11
@@ -2855,29 +1566,15 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___expr__call(func_name, argument_list, options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___expr__call(SEXP func_name_sexp, SEXP argument_list_sexp, SEXP options_sexp){
-	Rf_error("Cannot call dataset___expr__call(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // expression.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::Expression> dataset___expr__field_ref(std::string name);
 extern "C" SEXP _arrow_dataset___expr__field_ref(SEXP name_sexp){
 BEGIN_CPP11
 	arrow::r::Input<std::string>::type name(name_sexp);
-	return cpp11::as_sexp(dataset___expr__field_ref(name));
-END_CPP11
-}
-#else
-extern "C" SEXP _arrow_dataset___expr__field_ref(SEXP name_sexp){
-	Rf_error("Cannot call dataset___expr__field_ref(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+	return cpp11::as_sexp(dataset___expr__field_ref(name));
+END_CPP11
 }
-#endif
-
 // expression.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<ds::Expression> dataset___expr__scalar(const std::shared_ptr<arrow::Scalar>& x);
 extern "C" SEXP _arrow_dataset___expr__scalar(SEXP x_sexp){
 BEGIN_CPP11
@@ -2885,14 +1582,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___expr__scalar(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___expr__scalar(SEXP x_sexp){
-	Rf_error("Cannot call dataset___expr__scalar(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // expression.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string dataset___expr__ToString(const std::shared_ptr<ds::Expression>& x);
 extern "C" SEXP _arrow_dataset___expr__ToString(SEXP x_sexp){
 BEGIN_CPP11
@@ -2900,14 +1590,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(dataset___expr__ToString(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_dataset___expr__ToString(SEXP x_sexp){
-	Rf_error("Cannot call dataset___expr__ToString(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // feather.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void ipc___WriteFeather__Table(const std::shared_ptr<arrow::io::OutputStream>& stream, const std::shared_ptr<arrow::Table>& table, int version, int chunk_size, arrow::Compression::type compression, int compression_level);
 extern "C" SEXP _arrow_ipc___WriteFeather__Table(SEXP stream_sexp, SEXP table_sexp, SEXP version_sexp, SEXP chunk_size_sexp, SEXP compression_sexp, SEXP compression_level_sexp){
 BEGIN_CPP11
@@ -2921,14 +1604,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___WriteFeather__Table(SEXP stream_sexp, SEXP table_sexp, SEXP version_sexp, SEXP chunk_size_sexp, SEXP compression_sexp, SEXP compression_level_sexp){
-	Rf_error("Cannot call ipc___WriteFeather__Table(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // feather.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int ipc___feather___Reader__version(const std::shared_ptr<arrow::ipc::feather::Reader>& reader);
 extern "C" SEXP _arrow_ipc___feather___Reader__version(SEXP reader_sexp){
 BEGIN_CPP11
@@ -2936,14 +1612,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___feather___Reader__version(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___feather___Reader__version(SEXP reader_sexp){
-	Rf_error("Cannot call ipc___feather___Reader__version(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // feather.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> ipc___feather___Reader__Read(const std::shared_ptr<arrow::ipc::feather::Reader>& reader, SEXP columns);
 extern "C" SEXP _arrow_ipc___feather___Reader__Read(SEXP reader_sexp, SEXP columns_sexp){
 BEGIN_CPP11
@@ -2952,14 +1621,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___feather___Reader__Read(reader, columns));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___feather___Reader__Read(SEXP reader_sexp, SEXP columns_sexp){
-	Rf_error("Cannot call ipc___feather___Reader__Read(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // feather.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ipc::feather::Reader> ipc___feather___Reader__Open(const std::shared_ptr<arrow::io::RandomAccessFile>& stream);
 extern "C" SEXP _arrow_ipc___feather___Reader__Open(SEXP stream_sexp){
 BEGIN_CPP11
@@ -2967,14 +1629,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___feather___Reader__Open(stream));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___feather___Reader__Open(SEXP stream_sexp){
-	Rf_error("Cannot call ipc___feather___Reader__Open(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // feather.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::writable::strings ipc___feather___Reader__column_names(const std::shared_ptr<arrow::ipc::feather::Reader>& reader);
 extern "C" SEXP _arrow_ipc___feather___Reader__column_names(SEXP reader_sexp){
 BEGIN_CPP11
@@ -2982,14 +1637,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___feather___Reader__column_names(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___feather___Reader__column_names(SEXP reader_sexp){
-	Rf_error("Cannot call ipc___feather___Reader__column_names(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // field.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Field> Field__initialize(const std::string& name, const std::shared_ptr<arrow::DataType>& field, bool nullable);
 extern "C" SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){
 BEGIN_CPP11
@@ -2999,14 +1647,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Field__initialize(name, field, nullable));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){
-	Rf_error("Cannot call Field__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // field.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string Field__ToString(const std::shared_ptr<arrow::Field>& field);
 extern "C" SEXP _arrow_Field__ToString(SEXP field_sexp){
 BEGIN_CPP11
@@ -3014,14 +1655,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Field__ToString(field));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Field__ToString(SEXP field_sexp){
-	Rf_error("Cannot call Field__ToString(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // field.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string Field__name(const std::shared_ptr<arrow::Field>& field);
 extern "C" SEXP _arrow_Field__name(SEXP field_sexp){
 BEGIN_CPP11
@@ -3029,14 +1663,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Field__name(field));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Field__name(SEXP field_sexp){
-	Rf_error("Cannot call Field__name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // field.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Field__Equals(const std::shared_ptr<arrow::Field>& field, const std::shared_ptr<arrow::Field>& other);
 extern "C" SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){
 BEGIN_CPP11
@@ -3045,14 +1672,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Field__Equals(field, other));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){
-	Rf_error("Cannot call Field__Equals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // field.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Field__nullable(const std::shared_ptr<arrow::Field>& field);
 extern "C" SEXP _arrow_Field__nullable(SEXP field_sexp){
 BEGIN_CPP11
@@ -3060,14 +1680,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Field__nullable(field));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Field__nullable(SEXP field_sexp){
-	Rf_error("Cannot call Field__nullable(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // field.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Field__type(const std::shared_ptr<arrow::Field>& field);
 extern "C" SEXP _arrow_Field__type(SEXP field_sexp){
 BEGIN_CPP11
@@ -3075,14 +1688,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Field__type(field));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Field__type(SEXP field_sexp){
-	Rf_error("Cannot call Field__type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 fs::FileType fs___FileInfo__type(const std::shared_ptr<fs::FileInfo>& x);
 extern "C" SEXP _arrow_fs___FileInfo__type(SEXP x_sexp){
 BEGIN_CPP11
@@ -3090,14 +1696,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileInfo__type(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileInfo__type(SEXP x_sexp){
-	Rf_error("Cannot call fs___FileInfo__type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileInfo__set_type(const std::shared_ptr<fs::FileInfo>& x, fs::FileType type);
 extern "C" SEXP _arrow_fs___FileInfo__set_type(SEXP x_sexp, SEXP type_sexp){
 BEGIN_CPP11
@@ -3107,14 +1706,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileInfo__set_type(SEXP x_sexp, SEXP type_sexp){
-	Rf_error("Cannot call fs___FileInfo__set_type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string fs___FileInfo__path(const std::shared_ptr<fs::FileInfo>& x);
 extern "C" SEXP _arrow_fs___FileInfo__path(SEXP x_sexp){
 BEGIN_CPP11
@@ -3122,14 +1714,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileInfo__path(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileInfo__path(SEXP x_sexp){
-	Rf_error("Cannot call fs___FileInfo__path(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileInfo__set_path(const std::shared_ptr<fs::FileInfo>& x, const std::string& path);
 extern "C" SEXP _arrow_fs___FileInfo__set_path(SEXP x_sexp, SEXP path_sexp){
 BEGIN_CPP11
@@ -3139,14 +1724,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileInfo__set_path(SEXP x_sexp, SEXP path_sexp){
-	Rf_error("Cannot call fs___FileInfo__set_path(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t fs___FileInfo__size(const std::shared_ptr<fs::FileInfo>& x);
 extern "C" SEXP _arrow_fs___FileInfo__size(SEXP x_sexp){
 BEGIN_CPP11
@@ -3154,14 +1732,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileInfo__size(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileInfo__size(SEXP x_sexp){
-	Rf_error("Cannot call fs___FileInfo__size(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileInfo__set_size(const std::shared_ptr<fs::FileInfo>& x, int64_t size);
 extern "C" SEXP _arrow_fs___FileInfo__set_size(SEXP x_sexp, SEXP size_sexp){
 BEGIN_CPP11
@@ -3171,14 +1742,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileInfo__set_size(SEXP x_sexp, SEXP size_sexp){
-	Rf_error("Cannot call fs___FileInfo__set_size(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string fs___FileInfo__base_name(const std::shared_ptr<fs::FileInfo>& x);
 extern "C" SEXP _arrow_fs___FileInfo__base_name(SEXP x_sexp){
 BEGIN_CPP11
@@ -3186,14 +1750,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileInfo__base_name(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileInfo__base_name(SEXP x_sexp){
-	Rf_error("Cannot call fs___FileInfo__base_name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string fs___FileInfo__extension(const std::shared_ptr<fs::FileInfo>& x);
 extern "C" SEXP _arrow_fs___FileInfo__extension(SEXP x_sexp){
 BEGIN_CPP11
@@ -3201,14 +1758,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileInfo__extension(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileInfo__extension(SEXP x_sexp){
-	Rf_error("Cannot call fs___FileInfo__extension(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 SEXP fs___FileInfo__mtime(const std::shared_ptr<fs::FileInfo>& x);
 extern "C" SEXP _arrow_fs___FileInfo__mtime(SEXP x_sexp){
 BEGIN_CPP11
@@ -3216,14 +1766,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileInfo__mtime(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileInfo__mtime(SEXP x_sexp){
-	Rf_error("Cannot call fs___FileInfo__mtime(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileInfo__set_mtime(const std::shared_ptr<fs::FileInfo>& x, SEXP time);
 extern "C" SEXP _arrow_fs___FileInfo__set_mtime(SEXP x_sexp, SEXP time_sexp){
 BEGIN_CPP11
@@ -3233,14 +1776,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileInfo__set_mtime(SEXP x_sexp, SEXP time_sexp){
-	Rf_error("Cannot call fs___FileInfo__set_mtime(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string fs___FileSelector__base_dir(const std::shared_ptr<fs::FileSelector>& selector);
 extern "C" SEXP _arrow_fs___FileSelector__base_dir(SEXP selector_sexp){
 BEGIN_CPP11
@@ -3248,14 +1784,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSelector__base_dir(selector));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSelector__base_dir(SEXP selector_sexp){
-	Rf_error("Cannot call fs___FileSelector__base_dir(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool fs___FileSelector__allow_not_found(const std::shared_ptr<fs::FileSelector>& selector);
 extern "C" SEXP _arrow_fs___FileSelector__allow_not_found(SEXP selector_sexp){
 BEGIN_CPP11
@@ -3263,14 +1792,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSelector__allow_not_found(selector));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSelector__allow_not_found(SEXP selector_sexp){
-	Rf_error("Cannot call fs___FileSelector__allow_not_found(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool fs___FileSelector__recursive(const std::shared_ptr<fs::FileSelector>& selector);
 extern "C" SEXP _arrow_fs___FileSelector__recursive(SEXP selector_sexp){
 BEGIN_CPP11
@@ -3278,14 +1800,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSelector__recursive(selector));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSelector__recursive(SEXP selector_sexp){
-	Rf_error("Cannot call fs___FileSelector__recursive(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<fs::FileSelector> fs___FileSelector__create(const std::string& base_dir, bool allow_not_found, bool recursive);
 extern "C" SEXP _arrow_fs___FileSelector__create(SEXP base_dir_sexp, SEXP allow_not_found_sexp, SEXP recursive_sexp){
 BEGIN_CPP11
@@ -3295,14 +1810,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSelector__create(base_dir, allow_not_found, recursive));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSelector__create(SEXP base_dir_sexp, SEXP allow_not_found_sexp, SEXP recursive_sexp){
-	Rf_error("Cannot call fs___FileSelector__create(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list fs___FileSystem__GetTargetInfos_Paths(const std::shared_ptr<fs::FileSystem>& file_system, const std::vector<std::string>& paths);
 extern "C" SEXP _arrow_fs___FileSystem__GetTargetInfos_Paths(SEXP file_system_sexp, SEXP paths_sexp){
 BEGIN_CPP11
@@ -3311,14 +1819,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSystem__GetTargetInfos_Paths(file_system, paths));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__GetTargetInfos_Paths(SEXP file_system_sexp, SEXP paths_sexp){
-	Rf_error("Cannot call fs___FileSystem__GetTargetInfos_Paths(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list fs___FileSystem__GetTargetInfos_FileSelector(const std::shared_ptr<fs::FileSystem>& file_system, const std::shared_ptr<fs::FileSelector>& selector);
 extern "C" SEXP _arrow_fs___FileSystem__GetTargetInfos_FileSelector(SEXP file_system_sexp, SEXP selector_sexp){
 BEGIN_CPP11
@@ -3327,14 +1828,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSystem__GetTargetInfos_FileSelector(file_system, selector));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__GetTargetInfos_FileSelector(SEXP file_system_sexp, SEXP selector_sexp){
-	Rf_error("Cannot call fs___FileSystem__GetTargetInfos_FileSelector(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileSystem__CreateDir(const std::shared_ptr<fs::FileSystem>& file_system, const std::string& path, bool recursive);
 extern "C" SEXP _arrow_fs___FileSystem__CreateDir(SEXP file_system_sexp, SEXP path_sexp, SEXP recursive_sexp){
 BEGIN_CPP11
@@ -3345,14 +1839,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__CreateDir(SEXP file_system_sexp, SEXP path_sexp, SEXP recursive_sexp){
-	Rf_error("Cannot call fs___FileSystem__CreateDir(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileSystem__DeleteDir(const std::shared_ptr<fs::FileSystem>& file_system, const std::string& path);
 extern "C" SEXP _arrow_fs___FileSystem__DeleteDir(SEXP file_system_sexp, SEXP path_sexp){
 BEGIN_CPP11
@@ -3362,14 +1849,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__DeleteDir(SEXP file_system_sexp, SEXP path_sexp){
-	Rf_error("Cannot call fs___FileSystem__DeleteDir(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileSystem__DeleteDirContents(const std::shared_ptr<fs::FileSystem>& file_system, const std::string& path);
 extern "C" SEXP _arrow_fs___FileSystem__DeleteDirContents(SEXP file_system_sexp, SEXP path_sexp){
 BEGIN_CPP11
@@ -3379,14 +1859,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__DeleteDirContents(SEXP file_system_sexp, SEXP path_sexp){
-	Rf_error("Cannot call fs___FileSystem__DeleteDirContents(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileSystem__DeleteFile(const std::shared_ptr<fs::FileSystem>& file_system, const std::string& path);
 extern "C" SEXP _arrow_fs___FileSystem__DeleteFile(SEXP file_system_sexp, SEXP path_sexp){
 BEGIN_CPP11
@@ -3396,14 +1869,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__DeleteFile(SEXP file_system_sexp, SEXP path_sexp){
-	Rf_error("Cannot call fs___FileSystem__DeleteFile(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileSystem__DeleteFiles(const std::shared_ptr<fs::FileSystem>& file_system, const std::vector<std::string>& paths);
 extern "C" SEXP _arrow_fs___FileSystem__DeleteFiles(SEXP file_system_sexp, SEXP paths_sexp){
 BEGIN_CPP11
@@ -3413,14 +1879,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__DeleteFiles(SEXP file_system_sexp, SEXP paths_sexp){
-	Rf_error("Cannot call fs___FileSystem__DeleteFiles(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileSystem__Move(const std::shared_ptr<fs::FileSystem>& file_system, const std::string& src, const std::string& dest);
 extern "C" SEXP _arrow_fs___FileSystem__Move(SEXP file_system_sexp, SEXP src_sexp, SEXP dest_sexp){
 BEGIN_CPP11
@@ -3431,14 +1890,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__Move(SEXP file_system_sexp, SEXP src_sexp, SEXP dest_sexp){
-	Rf_error("Cannot call fs___FileSystem__Move(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___FileSystem__CopyFile(const std::shared_ptr<fs::FileSystem>& file_system, const std::string& src, const std::string& dest);
 extern "C" SEXP _arrow_fs___FileSystem__CopyFile(SEXP file_system_sexp, SEXP src_sexp, SEXP dest_sexp){
 BEGIN_CPP11
@@ -3449,14 +1901,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__CopyFile(SEXP file_system_sexp, SEXP src_sexp, SEXP dest_sexp){
-	Rf_error("Cannot call fs___FileSystem__CopyFile(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::InputStream> fs___FileSystem__OpenInputStream(const std::shared_ptr<fs::FileSystem>& file_system, const std::string& path);
 extern "C" SEXP _arrow_fs___FileSystem__OpenInputStream(SEXP file_system_sexp, SEXP path_sexp){
 BEGIN_CPP11
@@ -3465,14 +1910,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSystem__OpenInputStream(file_system, path));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__OpenInputStream(SEXP file_system_sexp, SEXP path_sexp){
-	Rf_error("Cannot call fs___FileSystem__OpenInputStream(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::RandomAccessFile> fs___FileSystem__OpenInputFile(const std::shared_ptr<fs::FileSystem>& file_system, const std::string& path);
 extern "C" SEXP _arrow_fs___FileSystem__OpenInputFile(SEXP file_system_sexp, SEXP path_sexp){
 BEGIN_CPP11
@@ -3481,14 +1919,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSystem__OpenInputFile(file_system, path));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__OpenInputFile(SEXP file_system_sexp, SEXP path_sexp){
-	Rf_error("Cannot call fs___FileSystem__OpenInputFile(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::OutputStream> fs___FileSystem__OpenOutputStream(const std::shared_ptr<fs::FileSystem>& file_system, const std::string& path);
 extern "C" SEXP _arrow_fs___FileSystem__OpenOutputStream(SEXP file_system_sexp, SEXP path_sexp){
 BEGIN_CPP11
@@ -3497,14 +1928,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSystem__OpenOutputStream(file_system, path));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__OpenOutputStream(SEXP file_system_sexp, SEXP path_sexp){
-	Rf_error("Cannot call fs___FileSystem__OpenOutputStream(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::OutputStream> fs___FileSystem__OpenAppendStream(const std::shared_ptr<fs::FileSystem>& file_system, const std::string& path);
 extern "C" SEXP _arrow_fs___FileSystem__OpenAppendStream(SEXP file_system_sexp, SEXP path_sexp){
 BEGIN_CPP11
@@ -3513,14 +1937,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSystem__OpenAppendStream(file_system, path));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__OpenAppendStream(SEXP file_system_sexp, SEXP path_sexp){
-	Rf_error("Cannot call fs___FileSystem__OpenAppendStream(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string fs___FileSystem__type_name(const std::shared_ptr<fs::FileSystem>& file_system);
 extern "C" SEXP _arrow_fs___FileSystem__type_name(SEXP file_system_sexp){
 BEGIN_CPP11
@@ -3528,28 +1945,14 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSystem__type_name(file_system));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystem__type_name(SEXP file_system_sexp){
-	Rf_error("Cannot call fs___FileSystem__type_name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<fs::LocalFileSystem> fs___LocalFileSystem__create();
 extern "C" SEXP _arrow_fs___LocalFileSystem__create(){
 BEGIN_CPP11
-	return cpp11::as_sexp(fs___LocalFileSystem__create());
-END_CPP11
-}
-#else
-extern "C" SEXP _arrow_fs___LocalFileSystem__create(){
-	Rf_error("Cannot call fs___LocalFileSystem__create(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+	return cpp11::as_sexp(fs___LocalFileSystem__create());
+END_CPP11
 }
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<fs::SubTreeFileSystem> fs___SubTreeFileSystem__create(const std::string& base_path, const std::shared_ptr<fs::FileSystem>& base_fs);
 extern "C" SEXP _arrow_fs___SubTreeFileSystem__create(SEXP base_path_sexp, SEXP base_fs_sexp){
 BEGIN_CPP11
@@ -3558,14 +1961,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___SubTreeFileSystem__create(base_path, base_fs));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___SubTreeFileSystem__create(SEXP base_path_sexp, SEXP base_fs_sexp){
-	Rf_error("Cannot call fs___SubTreeFileSystem__create(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<fs::FileSystem> fs___SubTreeFileSystem__base_fs(const std::shared_ptr<fs::SubTreeFileSystem>& file_system);
 extern "C" SEXP _arrow_fs___SubTreeFileSystem__base_fs(SEXP file_system_sexp){
 BEGIN_CPP11
@@ -3573,14 +1969,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___SubTreeFileSystem__base_fs(file_system));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___SubTreeFileSystem__base_fs(SEXP file_system_sexp){
-	Rf_error("Cannot call fs___SubTreeFileSystem__base_fs(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string fs___SubTreeFileSystem__base_path(const std::shared_ptr<fs::SubTreeFileSystem>& file_system);
 extern "C" SEXP _arrow_fs___SubTreeFileSystem__base_path(SEXP file_system_sexp){
 BEGIN_CPP11
@@ -3588,14 +1977,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___SubTreeFileSystem__base_path(file_system));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___SubTreeFileSystem__base_path(SEXP file_system_sexp){
-	Rf_error("Cannot call fs___SubTreeFileSystem__base_path(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::writable::list fs___FileSystemFromUri(const std::string& path);
 extern "C" SEXP _arrow_fs___FileSystemFromUri(SEXP path_sexp){
 BEGIN_CPP11
@@ -3603,14 +1985,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(fs___FileSystemFromUri(path));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___FileSystemFromUri(SEXP path_sexp){
-	Rf_error("Cannot call fs___FileSystemFromUri(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void fs___CopyFiles(const std::shared_ptr<fs::FileSystem>& source_fs, const std::shared_ptr<fs::FileSelector>& source_sel, const std::shared_ptr<fs::FileSystem>& destination_fs, const std::string& destination_base_dir, int64_t chunk_size, bool use_threads);
 extern "C" SEXP _arrow_fs___CopyFiles(SEXP source_fs_sexp, SEXP source_sel_sexp, SEXP destination_fs_sexp, SEXP destination_base_dir_sexp, SEXP chunk_size_sexp, SEXP use_threads_sexp){
 BEGIN_CPP11
@@ -3624,12 +1999,6 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_fs___CopyFiles(SEXP source_fs_sexp, SEXP source_sel_sexp, SEXP destination_fs_sexp, SEXP destination_base_dir_sexp, SEXP chunk_size_sexp, SEXP use_threads_sexp){
-	Rf_error("Cannot call fs___CopyFiles(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // filesystem.cpp
 #if defined(ARROW_R_WITH_S3)
 std::shared_ptr<fs::S3FileSystem> fs___S3FileSystem__create(bool anonymous, std::string access_key, std::string secret_key, std::string session_token, std::string role_arn, std::string session_name, std::string external_id, int load_frequency, std::string region, std::string endpoint_override, std::string scheme, bool background_writes);
@@ -3672,7 +2041,6 @@ extern "C" SEXP _arrow_fs___S3FileSystem__region(SEXP fs_sexp){
 #endif
 
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Buffer> io___Readable__Read(const std::shared_ptr<arrow::io::Readable>& x, int64_t nbytes);
 extern "C" SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){
 BEGIN_CPP11
@@ -3681,14 +2049,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___Readable__Read(x, nbytes));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){
-	Rf_error("Cannot call io___Readable__Read(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void io___InputStream__Close(const std::shared_ptr<arrow::io::InputStream>& x);
 extern "C" SEXP _arrow_io___InputStream__Close(SEXP x_sexp){
 BEGIN_CPP11
@@ -3697,14 +2058,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___InputStream__Close(SEXP x_sexp){
-	Rf_error("Cannot call io___InputStream__Close(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void io___OutputStream__Close(const std::shared_ptr<arrow::io::OutputStream>& x);
 extern "C" SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){
 BEGIN_CPP11
@@ -3713,14 +2067,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){
-	Rf_error("Cannot call io___OutputStream__Close(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t io___RandomAccessFile__GetSize(const std::shared_ptr<arrow::io::RandomAccessFile>& x);
 extern "C" SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){
 BEGIN_CPP11
@@ -3728,14 +2075,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___RandomAccessFile__GetSize(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){
-	Rf_error("Cannot call io___RandomAccessFile__GetSize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool io___RandomAccessFile__supports_zero_copy(const std::shared_ptr<arrow::io::RandomAccessFile>& x);
 extern "C" SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){
 BEGIN_CPP11
@@ -3743,14 +2083,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___RandomAccessFile__supports_zero_copy(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){
-	Rf_error("Cannot call io___RandomAccessFile__supports_zero_copy(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void io___RandomAccessFile__Seek(const std::shared_ptr<arrow::io::RandomAccessFile>& x, int64_t position);
 extern "C" SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){
 BEGIN_CPP11
@@ -3760,14 +2093,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){
-	Rf_error("Cannot call io___RandomAccessFile__Seek(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t io___RandomAccessFile__Tell(const std::shared_ptr<arrow::io::RandomAccessFile>& x);
 extern "C" SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){
 BEGIN_CPP11
@@ -3775,14 +2101,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___RandomAccessFile__Tell(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){
-	Rf_error("Cannot call io___RandomAccessFile__Tell(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Buffer> io___RandomAccessFile__Read0(const std::shared_ptr<arrow::io::RandomAccessFile>& x);
 extern "C" SEXP _arrow_io___RandomAccessFile__Read0(SEXP x_sexp){
 BEGIN_CPP11
@@ -3790,14 +2109,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___RandomAccessFile__Read0(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___RandomAccessFile__Read0(SEXP x_sexp){
-	Rf_error("Cannot call io___RandomAccessFile__Read0(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Buffer> io___RandomAccessFile__ReadAt(const std::shared_ptr<arrow::io::RandomAccessFile>& x, int64_t position, int64_t nbytes);
 extern "C" SEXP _arrow_io___RandomAccessFile__ReadAt(SEXP x_sexp, SEXP position_sexp, SEXP nbytes_sexp){
 BEGIN_CPP11
@@ -3807,14 +2119,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___RandomAccessFile__ReadAt(x, position, nbytes));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___RandomAccessFile__ReadAt(SEXP x_sexp, SEXP position_sexp, SEXP nbytes_sexp){
-	Rf_error("Cannot call io___RandomAccessFile__ReadAt(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::MemoryMappedFile> io___MemoryMappedFile__Create(const std::string& path, int64_t size);
 extern "C" SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){
 BEGIN_CPP11
@@ -3823,14 +2128,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___MemoryMappedFile__Create(path, size));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){
-	Rf_error("Cannot call io___MemoryMappedFile__Create(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::MemoryMappedFile> io___MemoryMappedFile__Open(const std::string& path, arrow::io::FileMode::type mode);
 extern "C" SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){
 BEGIN_CPP11
@@ -3839,14 +2137,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___MemoryMappedFile__Open(path, mode));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){
-	Rf_error("Cannot call io___MemoryMappedFile__Open(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void io___MemoryMappedFile__Resize(const std::shared_ptr<arrow::io::MemoryMappedFile>& x, int64_t size);
 extern "C" SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){
 BEGIN_CPP11
@@ -3856,14 +2147,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){
-	Rf_error("Cannot call io___MemoryMappedFile__Resize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::ReadableFile> io___ReadableFile__Open(const std::string& path);
 extern "C" SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){
 BEGIN_CPP11
@@ -3871,14 +2155,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___ReadableFile__Open(path));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){
-	Rf_error("Cannot call io___ReadableFile__Open(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::BufferReader> io___BufferReader__initialize(const std::shared_ptr<arrow::Buffer>& buffer);
 extern "C" SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){
 BEGIN_CPP11
@@ -3886,14 +2163,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___BufferReader__initialize(buffer));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){
-	Rf_error("Cannot call io___BufferReader__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void io___Writable__write(const std::shared_ptr<arrow::io::Writable>& stream, const std::shared_ptr<arrow::Buffer>& buf);
 extern "C" SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){
 BEGIN_CPP11
@@ -3903,14 +2173,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){
-	Rf_error("Cannot call io___Writable__write(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t io___OutputStream__Tell(const std::shared_ptr<arrow::io::OutputStream>& stream);
 extern "C" SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){
 BEGIN_CPP11
@@ -3918,14 +2181,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___OutputStream__Tell(stream));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){
-	Rf_error("Cannot call io___OutputStream__Tell(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::FileOutputStream> io___FileOutputStream__Open(const std::string& path);
 extern "C" SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){
 BEGIN_CPP11
@@ -3933,14 +2189,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___FileOutputStream__Open(path));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){
-	Rf_error("Cannot call io___FileOutputStream__Open(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::io::BufferOutputStream> io___BufferOutputStream__Create(int64_t initial_capacity);
 extern "C" SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){
 BEGIN_CPP11
@@ -3948,14 +2197,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___BufferOutputStream__Create(initial_capacity));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){
-	Rf_error("Cannot call io___BufferOutputStream__Create(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t io___BufferOutputStream__capacity(const std::shared_ptr<arrow::io::BufferOutputStream>& stream);
 extern "C" SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){
 BEGIN_CPP11
@@ -3963,14 +2205,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___BufferOutputStream__capacity(stream));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){
-	Rf_error("Cannot call io___BufferOutputStream__capacity(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Buffer> io___BufferOutputStream__Finish(const std::shared_ptr<arrow::io::BufferOutputStream>& stream);
 extern "C" SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){
 BEGIN_CPP11
@@ -3978,14 +2213,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___BufferOutputStream__Finish(stream));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){
-	Rf_error("Cannot call io___BufferOutputStream__Finish(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t io___BufferOutputStream__Tell(const std::shared_ptr<arrow::io::BufferOutputStream>& stream);
 extern "C" SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){
 BEGIN_CPP11
@@ -3993,14 +2221,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(io___BufferOutputStream__Tell(stream));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){
-	Rf_error("Cannot call io___BufferOutputStream__Tell(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // io.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void io___BufferOutputStream__Write(const std::shared_ptr<arrow::io::BufferOutputStream>& stream, cpp11::raws bytes);
 extern "C" SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){
 BEGIN_CPP11
@@ -4010,14 +2231,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){
-	Rf_error("Cannot call io___BufferOutputStream__Write(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // json.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::json::ReadOptions> json___ReadOptions__initialize(bool use_threads, int block_size);
 extern "C" SEXP _arrow_json___ReadOptions__initialize(SEXP use_threads_sexp, SEXP block_size_sexp){
 BEGIN_CPP11
@@ -4026,14 +2240,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(json___ReadOptions__initialize(use_threads, block_size));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_json___ReadOptions__initialize(SEXP use_threads_sexp, SEXP block_size_sexp){
-	Rf_error("Cannot call json___ReadOptions__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // json.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::json::ParseOptions> json___ParseOptions__initialize(bool newlines_in_values);
 extern "C" SEXP _arrow_json___ParseOptions__initialize(SEXP newlines_in_values_sexp){
 BEGIN_CPP11
@@ -4041,14 +2248,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(json___ParseOptions__initialize(newlines_in_values));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_json___ParseOptions__initialize(SEXP newlines_in_values_sexp){
-	Rf_error("Cannot call json___ParseOptions__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // json.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::json::TableReader> json___TableReader__Make(const std::shared_ptr<arrow::io::InputStream>& input, const std::shared_ptr<arrow::json::ReadOptions>& read_options, const std::shared_ptr<arrow::json::ParseOptions>& parse_options);
 extern "C" SEXP _arrow_json___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp){
 BEGIN_CPP11
@@ -4058,14 +2258,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(json___TableReader__Make(input, read_options, parse_options));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_json___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp){
-	Rf_error("Cannot call json___TableReader__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // json.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> json___TableReader__Read(const std::shared_ptr<arrow::json::TableReader>& table_reader);
 extern "C" SEXP _arrow_json___TableReader__Read(SEXP table_reader_sexp){
 BEGIN_CPP11
@@ -4073,28 +2266,14 @@ BEGIN_CPP11
 	return cpp11::as_sexp(json___TableReader__Read(table_reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_json___TableReader__Read(SEXP table_reader_sexp){
-	Rf_error("Cannot call json___TableReader__Read(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // memorypool.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::MemoryPool> MemoryPool__default();
 extern "C" SEXP _arrow_MemoryPool__default(){
 BEGIN_CPP11
 	return cpp11::as_sexp(MemoryPool__default());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_MemoryPool__default(){
-	Rf_error("Cannot call MemoryPool__default(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // memorypool.cpp
-#if defined(ARROW_R_WITH_ARROW)
 double MemoryPool__bytes_allocated(const std::shared_ptr<arrow::MemoryPool>& pool);
 extern "C" SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){
 BEGIN_CPP11
@@ -4102,14 +2281,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(MemoryPool__bytes_allocated(pool));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){
-	Rf_error("Cannot call MemoryPool__bytes_allocated(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // memorypool.cpp
-#if defined(ARROW_R_WITH_ARROW)
 double MemoryPool__max_memory(const std::shared_ptr<arrow::MemoryPool>& pool);
 extern "C" SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){
 BEGIN_CPP11
@@ -4117,14 +2289,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(MemoryPool__max_memory(pool));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){
-	Rf_error("Cannot call MemoryPool__max_memory(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // memorypool.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string MemoryPool__backend_name(const std::shared_ptr<arrow::MemoryPool>& pool);
 extern "C" SEXP _arrow_MemoryPool__backend_name(SEXP pool_sexp){
 BEGIN_CPP11
@@ -4132,28 +2297,14 @@ BEGIN_CPP11
 	return cpp11::as_sexp(MemoryPool__backend_name(pool));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_MemoryPool__backend_name(SEXP pool_sexp){
-	Rf_error("Cannot call MemoryPool__backend_name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // memorypool.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::vector<std::string> supported_memory_backends();
 extern "C" SEXP _arrow_supported_memory_backends(){
 BEGIN_CPP11
 	return cpp11::as_sexp(supported_memory_backends());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_supported_memory_backends(){
-	Rf_error("Cannot call supported_memory_backends(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t ipc___Message__body_length(const std::unique_ptr<arrow::ipc::Message>& message);
 extern "C" SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){
 BEGIN_CPP11
@@ -4161,14 +2312,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___Message__body_length(message));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){
-	Rf_error("Cannot call ipc___Message__body_length(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Buffer> ipc___Message__metadata(const std::unique_ptr<arrow::ipc::Message>& message);
 extern "C" SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){
 BEGIN_CPP11
@@ -4176,14 +2320,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___Message__metadata(message));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){
-	Rf_error("Cannot call ipc___Message__metadata(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Buffer> ipc___Message__body(const std::unique_ptr<arrow::ipc::Message>& message);
 extern "C" SEXP _arrow_ipc___Message__body(SEXP message_sexp){
 BEGIN_CPP11
@@ -4191,14 +2328,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___Message__body(message));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___Message__body(SEXP message_sexp){
-	Rf_error("Cannot call ipc___Message__body(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t ipc___Message__Verify(const std::unique_ptr<arrow::ipc::Message>& message);
 extern "C" SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){
 BEGIN_CPP11
@@ -4206,14 +2336,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___Message__Verify(message));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){
-	Rf_error("Cannot call ipc___Message__Verify(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 arrow::ipc::MessageType ipc___Message__type(const std::unique_ptr<arrow::ipc::Message>& message);
 extern "C" SEXP _arrow_ipc___Message__type(SEXP message_sexp){
 BEGIN_CPP11
@@ -4221,30 +2344,16 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___Message__type(message));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___Message__type(SEXP message_sexp){
-	Rf_error("Cannot call ipc___Message__type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool ipc___Message__Equals(const std::unique_ptr<arrow::ipc::Message>& x, const std::unique_ptr<arrow::ipc::Message>& y);
 extern "C" SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){
 BEGIN_CPP11
 	arrow::r::Input<const std::unique_ptr<arrow::ipc::Message>&>::type x(x_sexp);
 	arrow::r::Input<const std::unique_ptr<arrow::ipc::Message>&>::type y(y_sexp);
-	return cpp11::as_sexp(ipc___Message__Equals(x, y));
-END_CPP11
-}
-#else
-extern "C" SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){
-	Rf_error("Cannot call ipc___Message__Equals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+	return cpp11::as_sexp(ipc___Message__Equals(x, y));
+END_CPP11
 }
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> ipc___ReadRecordBatch__Message__Schema(const std::unique_ptr<arrow::ipc::Message>& message, const std::shared_ptr<arrow::Schema>& schema);
 extern "C" SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){
 BEGIN_CPP11
@@ -4253,14 +2362,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___ReadRecordBatch__Message__Schema(message, schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){
-	Rf_error("Cannot call ipc___ReadRecordBatch__Message__Schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> ipc___ReadSchema_InputStream(const std::shared_ptr<arrow::io::InputStream>& stream);
 extern "C" SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){
 BEGIN_CPP11
@@ -4268,14 +2370,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___ReadSchema_InputStream(stream));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){
-	Rf_error("Cannot call ipc___ReadSchema_InputStream(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> ipc___ReadSchema_Message(const std::unique_ptr<arrow::ipc::Message>& message);
 extern "C" SEXP _arrow_ipc___ReadSchema_Message(SEXP message_sexp){
 BEGIN_CPP11
@@ -4283,14 +2378,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___ReadSchema_Message(message));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___ReadSchema_Message(SEXP message_sexp){
-	Rf_error("Cannot call ipc___ReadSchema_Message(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ipc::MessageReader> ipc___MessageReader__Open(const std::shared_ptr<arrow::io::InputStream>& stream);
 extern "C" SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){
 BEGIN_CPP11
@@ -4298,14 +2386,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___MessageReader__Open(stream));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){
-	Rf_error("Cannot call ipc___MessageReader__Open(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ipc::Message> ipc___MessageReader__ReadNextMessage(const std::unique_ptr<arrow::ipc::MessageReader>& reader);
 extern "C" SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){
 BEGIN_CPP11
@@ -4313,14 +2394,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___MessageReader__ReadNextMessage(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){
-	Rf_error("Cannot call ipc___MessageReader__ReadNextMessage(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // message.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ipc::Message> ipc___ReadMessage(const std::shared_ptr<arrow::io::InputStream>& stream);
 extern "C" SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){
 BEGIN_CPP11
@@ -4328,14 +2402,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___ReadMessage(stream));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){
-	Rf_error("Cannot call ipc___ReadMessage(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<parquet::ArrowReaderProperties> parquet___arrow___ArrowReaderProperties__Make(bool use_threads);
 extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__Make(SEXP use_threads_sexp){
 BEGIN_CPP11
@@ -4343,14 +2410,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___ArrowReaderProperties__Make(use_threads));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__Make(SEXP use_threads_sexp){
-	Rf_error("Cannot call parquet___arrow___ArrowReaderProperties__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___arrow___ArrowReaderProperties__set_use_threads(const std::shared_ptr<parquet::ArrowReaderProperties>& properties, bool use_threads);
 extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__set_use_threads(SEXP properties_sexp, SEXP use_threads_sexp){
 BEGIN_CPP11
@@ -4360,14 +2420,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__set_use_threads(SEXP properties_sexp, SEXP use_threads_sexp){
-	Rf_error("Cannot call parquet___arrow___ArrowReaderProperties__set_use_threads(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool parquet___arrow___ArrowReaderProperties__get_use_threads(const std::shared_ptr<parquet::ArrowReaderProperties>& properties, bool use_threads);
 extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__get_use_threads(SEXP properties_sexp, SEXP use_threads_sexp){
 BEGIN_CPP11
@@ -4376,14 +2429,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___ArrowReaderProperties__get_use_threads(properties, use_threads));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__get_use_threads(SEXP properties_sexp, SEXP use_threads_sexp){
-	Rf_error("Cannot call parquet___arrow___ArrowReaderProperties__get_use_threads(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool parquet___arrow___ArrowReaderProperties__get_read_dictionary(const std::shared_ptr<parquet::ArrowReaderProperties>& properties, int column_index);
 extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__get_read_dictionary(SEXP properties_sexp, SEXP column_index_sexp){
 BEGIN_CPP11
@@ -4392,14 +2438,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___ArrowReaderProperties__get_read_dictionary(properties, column_index));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__get_read_dictionary(SEXP properties_sexp, SEXP column_index_sexp){
-	Rf_error("Cannot call parquet___arrow___ArrowReaderProperties__get_read_dictionary(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___arrow___ArrowReaderProperties__set_read_dictionary(const std::shared_ptr<parquet::ArrowReaderProperties>& properties, int column_index, bool read_dict);
 extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__set_read_dictionary(SEXP properties_sexp, SEXP column_index_sexp, SEXP read_dict_sexp){
 BEGIN_CPP11
@@ -4410,14 +2449,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__set_read_dictionary(SEXP properties_sexp, SEXP column_index_sexp, SEXP read_dict_sexp){
-	Rf_error("Cannot call parquet___arrow___ArrowReaderProperties__set_read_dictionary(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<parquet::arrow::FileReader> parquet___arrow___FileReader__OpenFile(const std::shared_ptr<arrow::io::RandomAccessFile>& file, const std::shared_ptr<parquet::ArrowReaderProperties>& props);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__OpenFile(SEXP file_sexp, SEXP props_sexp){
 BEGIN_CPP11
@@ -4426,14 +2458,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__OpenFile(file, props));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__OpenFile(SEXP file_sexp, SEXP props_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__OpenFile(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadTable1(const std::shared_ptr<parquet::arrow::FileReader>& reader);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadTable1(SEXP reader_sexp){
 BEGIN_CPP11
@@ -4441,14 +2466,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__ReadTable1(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadTable1(SEXP reader_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__ReadTable1(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadTable2(const std::shared_ptr<parquet::arrow::FileReader>& reader, const std::vector<int>& column_indices);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadTable2(SEXP reader_sexp, SEXP column_indices_sexp){
 BEGIN_CPP11
@@ -4457,14 +2475,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__ReadTable2(reader, column_indices));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadTable2(SEXP reader_sexp, SEXP column_indices_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__ReadTable2(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadRowGroup1(const std::shared_ptr<parquet::arrow::FileReader>& reader, int i);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadRowGroup1(SEXP reader_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -4473,14 +2484,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__ReadRowGroup1(reader, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadRowGroup1(SEXP reader_sexp, SEXP i_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__ReadRowGroup1(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadRowGroup2(const std::shared_ptr<parquet::arrow::FileReader>& reader, int i, const std::vector<int>& column_indices);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadRowGroup2(SEXP reader_sexp, SEXP i_sexp, SEXP column_indices_sexp){
 BEGIN_CPP11
@@ -4490,14 +2494,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__ReadRowGroup2(reader, i, column_indices));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadRowGroup2(SEXP reader_sexp, SEXP i_sexp, SEXP column_indices_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__ReadRowGroup2(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadRowGroups1(const std::shared_ptr<parquet::arrow::FileReader>& reader, const std::vector<int>& row_groups);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadRowGroups1(SEXP reader_sexp, SEXP row_groups_sexp){
 BEGIN_CPP11
@@ -4506,14 +2503,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__ReadRowGroups1(reader, row_groups));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadRowGroups1(SEXP reader_sexp, SEXP row_groups_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__ReadRowGroups1(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadRowGroups2(const std::shared_ptr<parquet::arrow::FileReader>& reader, const std::vector<int>& row_groups, const std::vector<int>& column_indices);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadRowGroups2(SEXP reader_sexp, SEXP row_groups_sexp, SEXP column_indices_sexp){
 BEGIN_CPP11
@@ -4523,14 +2513,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__ReadRowGroups2(reader, row_groups, column_indices));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadRowGroups2(SEXP reader_sexp, SEXP row_groups_sexp, SEXP column_indices_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__ReadRowGroups2(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int64_t parquet___arrow___FileReader__num_rows(const std::shared_ptr<parquet::arrow::FileReader>& reader);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__num_rows(SEXP reader_sexp){
 BEGIN_CPP11
@@ -4538,14 +2521,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__num_rows(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__num_rows(SEXP reader_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__num_rows(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int parquet___arrow___FileReader__num_columns(const std::shared_ptr<parquet::arrow::FileReader>& reader);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__num_columns(SEXP reader_sexp){
 BEGIN_CPP11
@@ -4553,14 +2529,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__num_columns(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__num_columns(SEXP reader_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__num_columns(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int parquet___arrow___FileReader__num_row_groups(const std::shared_ptr<parquet::arrow::FileReader>& reader);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__num_row_groups(SEXP reader_sexp){
 BEGIN_CPP11
@@ -4568,14 +2537,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__num_row_groups(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__num_row_groups(SEXP reader_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__num_row_groups(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ChunkedArray> parquet___arrow___FileReader__ReadColumn(const std::shared_ptr<parquet::arrow::FileReader>& reader, int i);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadColumn(SEXP reader_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -4584,14 +2546,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__ReadColumn(reader, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__ReadColumn(SEXP reader_sexp, SEXP i_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__ReadColumn(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<parquet::ArrowWriterProperties> parquet___ArrowWriterProperties___create(bool allow_truncated_timestamps, bool use_deprecated_int96_timestamps, int timestamp_unit);
 extern "C" SEXP _arrow_parquet___ArrowWriterProperties___create(SEXP allow_truncated_timestamps_sexp, SEXP use_deprecated_int96_timestamps_sexp, SEXP timestamp_unit_sexp){
 BEGIN_CPP11
@@ -4601,28 +2556,14 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___ArrowWriterProperties___create(allow_truncated_timestamps, use_deprecated_int96_timestamps, timestamp_unit));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___ArrowWriterProperties___create(SEXP allow_truncated_timestamps_sexp, SEXP use_deprecated_int96_timestamps_sexp, SEXP timestamp_unit_sexp){
-	Rf_error("Cannot call parquet___ArrowWriterProperties___create(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<parquet::WriterPropertiesBuilder> parquet___WriterProperties___Builder__create();
 extern "C" SEXP _arrow_parquet___WriterProperties___Builder__create(){
 BEGIN_CPP11
 	return cpp11::as_sexp(parquet___WriterProperties___Builder__create());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___WriterProperties___Builder__create(){
-	Rf_error("Cannot call parquet___WriterProperties___Builder__create(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___WriterProperties___Builder__version(const std::shared_ptr<parquet::WriterPropertiesBuilder>& builder, const parquet::ParquetVersion::type& version);
 extern "C" SEXP _arrow_parquet___WriterProperties___Builder__version(SEXP builder_sexp, SEXP version_sexp){
 BEGIN_CPP11
@@ -4632,14 +2573,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___WriterProperties___Builder__version(SEXP builder_sexp, SEXP version_sexp){
-	Rf_error("Cannot call parquet___WriterProperties___Builder__version(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___ArrowWriterProperties___Builder__set_compressions(const std::shared_ptr<parquet::WriterPropertiesBuilder>& builder, const std::vector<std::string>& paths, cpp11::integers types);
 extern "C" SEXP _arrow_parquet___ArrowWriterProperties___Builder__set_compressions(SEXP builder_sexp, SEXP paths_sexp, SEXP types_sexp){
 BEGIN_CPP11
@@ -4650,14 +2584,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___ArrowWriterProperties___Builder__set_compressions(SEXP builder_sexp, SEXP paths_sexp, SEXP types_sexp){
-	Rf_error("Cannot call parquet___ArrowWriterProperties___Builder__set_compressions(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___ArrowWriterProperties___Builder__set_compression_levels(const std::shared_ptr<parquet::WriterPropertiesBuilder>& builder, const std::vector<std::string>& paths, cpp11::integers levels);
 extern "C" SEXP _arrow_parquet___ArrowWriterProperties___Builder__set_compression_levels(SEXP builder_sexp, SEXP paths_sexp, SEXP levels_sexp){
 BEGIN_CPP11
@@ -4668,14 +2595,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___ArrowWriterProperties___Builder__set_compression_levels(SEXP builder_sexp, SEXP paths_sexp, SEXP levels_sexp){
-	Rf_error("Cannot call parquet___ArrowWriterProperties___Builder__set_compression_levels(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___ArrowWriterProperties___Builder__set_use_dictionary(const std::shared_ptr<parquet::WriterPropertiesBuilder>& builder, const std::vector<std::string>& paths, cpp11::logicals use_dictionary);
 extern "C" SEXP _arrow_parquet___ArrowWriterProperties___Builder__set_use_dictionary(SEXP builder_sexp, SEXP paths_sexp, SEXP use_dictionary_sexp){
 BEGIN_CPP11
@@ -4686,14 +2606,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___ArrowWriterProperties___Builder__set_use_dictionary(SEXP builder_sexp, SEXP paths_sexp, SEXP use_dictionary_sexp){
-	Rf_error("Cannot call parquet___ArrowWriterProperties___Builder__set_use_dictionary(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___ArrowWriterProperties___Builder__set_write_statistics(const std::shared_ptr<parquet::WriterPropertiesBuilder>& builder, const std::vector<std::string>& paths, cpp11::logicals write_statistics);
 extern "C" SEXP _arrow_parquet___ArrowWriterProperties___Builder__set_write_statistics(SEXP builder_sexp, SEXP paths_sexp, SEXP write_statistics_sexp){
 BEGIN_CPP11
@@ -4704,14 +2617,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___ArrowWriterProperties___Builder__set_write_statistics(SEXP builder_sexp, SEXP paths_sexp, SEXP write_statistics_sexp){
-	Rf_error("Cannot call parquet___ArrowWriterProperties___Builder__set_write_statistics(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___ArrowWriterProperties___Builder__data_page_size(const std::shared_ptr<parquet::WriterPropertiesBuilder>& builder, int64_t data_page_size);
 extern "C" SEXP _arrow_parquet___ArrowWriterProperties___Builder__data_page_size(SEXP builder_sexp, SEXP data_page_size_sexp){
 BEGIN_CPP11
@@ -4721,14 +2627,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___ArrowWriterProperties___Builder__data_page_size(SEXP builder_sexp, SEXP data_page_size_sexp){
-	Rf_error("Cannot call parquet___ArrowWriterProperties___Builder__data_page_size(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<parquet::WriterProperties> parquet___WriterProperties___Builder__build(const std::shared_ptr<parquet::WriterPropertiesBuilder>& builder);
 extern "C" SEXP _arrow_parquet___WriterProperties___Builder__build(SEXP builder_sexp){
 BEGIN_CPP11
@@ -4736,14 +2635,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___WriterProperties___Builder__build(builder));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___WriterProperties___Builder__build(SEXP builder_sexp){
-	Rf_error("Cannot call parquet___WriterProperties___Builder__build(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<parquet::arrow::FileWriter> parquet___arrow___ParquetFileWriter__Open(const std::shared_ptr<arrow::Schema>& schema, const std::shared_ptr<arrow::io::OutputStream>& sink, const std::shared_ptr<parquet::WriterProperties>& properties, const std::shared_ptr<parquet::ArrowWriterProperties>& arrow_properties);
 extern "C" SEXP _arrow_parquet___arrow___ParquetFileWriter__Open(SEXP schema_sexp, SEXP sink_sexp, SEXP properties_sexp, SEXP arrow_properties_sexp){
 BEGIN_CPP11
@@ -4754,14 +2646,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___ParquetFileWriter__Open(schema, sink, properties, arrow_properties));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___ParquetFileWriter__Open(SEXP schema_sexp, SEXP sink_sexp, SEXP properties_sexp, SEXP arrow_properties_sexp){
-	Rf_error("Cannot call parquet___arrow___ParquetFileWriter__Open(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___arrow___FileWriter__WriteTable(const std::shared_ptr<parquet::arrow::FileWriter>& writer, const std::shared_ptr<arrow::Table>& table, int64_t chunk_size);
 extern "C" SEXP _arrow_parquet___arrow___FileWriter__WriteTable(SEXP writer_sexp, SEXP table_sexp, SEXP chunk_size_sexp){
 BEGIN_CPP11
@@ -4772,14 +2657,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileWriter__WriteTable(SEXP writer_sexp, SEXP table_sexp, SEXP chunk_size_sexp){
-	Rf_error("Cannot call parquet___arrow___FileWriter__WriteTable(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___arrow___FileWriter__Close(const std::shared_ptr<parquet::arrow::FileWriter>& writer);
 extern "C" SEXP _arrow_parquet___arrow___FileWriter__Close(SEXP writer_sexp){
 BEGIN_CPP11
@@ -4788,14 +2666,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileWriter__Close(SEXP writer_sexp){
-	Rf_error("Cannot call parquet___arrow___FileWriter__Close(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void parquet___arrow___WriteTable(const std::shared_ptr<arrow::Table>& table, const std::shared_ptr<arrow::io::OutputStream>& sink, const std::shared_ptr<parquet::WriterProperties>& properties, const std::shared_ptr<parquet::ArrowWriterProperties>& arrow_properties);
 extern "C" SEXP _arrow_parquet___arrow___WriteTable(SEXP table_sexp, SEXP sink_sexp, SEXP properties_sexp, SEXP arrow_properties_sexp){
 BEGIN_CPP11
@@ -4807,14 +2678,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___WriteTable(SEXP table_sexp, SEXP sink_sexp, SEXP properties_sexp, SEXP arrow_properties_sexp){
-	Rf_error("Cannot call parquet___arrow___WriteTable(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // parquet.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> parquet___arrow___FileReader__GetSchema(const std::shared_ptr<parquet::arrow::FileReader>& reader);
 extern "C" SEXP _arrow_parquet___arrow___FileReader__GetSchema(SEXP reader_sexp){
 BEGIN_CPP11
@@ -4822,14 +2686,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(parquet___arrow___FileReader__GetSchema(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__GetSchema(SEXP reader_sexp){
-	Rf_error("Cannot call parquet___arrow___FileReader__GetSchema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> ImportArray(arrow::r::Pointer<struct ArrowArray> array, arrow::r::Pointer<struct ArrowSchema> schema);
 extern "C" SEXP _arrow_ImportArray(SEXP array_sexp, SEXP schema_sexp){
 BEGIN_CPP11
@@ -4838,14 +2695,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ImportArray(array, schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ImportArray(SEXP array_sexp, SEXP schema_sexp){
-	Rf_error("Cannot call ImportArray(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> ImportRecordBatch(arrow::r::Pointer<struct ArrowArray> array, arrow::r::Pointer<struct ArrowSchema> schema);
 extern "C" SEXP _arrow_ImportRecordBatch(SEXP array_sexp, SEXP schema_sexp){
 BEGIN_CPP11
@@ -4854,14 +2704,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ImportRecordBatch(array, schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ImportRecordBatch(SEXP array_sexp, SEXP schema_sexp){
-	Rf_error("Cannot call ImportRecordBatch(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> ImportSchema(arrow::r::Pointer<struct ArrowSchema> schema);
 extern "C" SEXP _arrow_ImportSchema(SEXP schema_sexp){
 BEGIN_CPP11
@@ -4869,28 +2712,14 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ImportSchema(schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ImportSchema(SEXP schema_sexp){
-	Rf_error("Cannot call ImportSchema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 arrow::r::Pointer<struct ArrowSchema> allocate_arrow_schema();
 extern "C" SEXP _arrow_allocate_arrow_schema(){
 BEGIN_CPP11
 	return cpp11::as_sexp(allocate_arrow_schema());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_allocate_arrow_schema(){
-	Rf_error("Cannot call allocate_arrow_schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void delete_arrow_schema(arrow::r::Pointer<struct ArrowSchema> ptr);
 extern "C" SEXP _arrow_delete_arrow_schema(SEXP ptr_sexp){
 BEGIN_CPP11
@@ -4899,28 +2728,14 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_delete_arrow_schema(SEXP ptr_sexp){
-	Rf_error("Cannot call delete_arrow_schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 arrow::r::Pointer<struct ArrowArray> allocate_arrow_array();
 extern "C" SEXP _arrow_allocate_arrow_array(){
 BEGIN_CPP11
-	return cpp11::as_sexp(allocate_arrow_array());
-END_CPP11
-}
-#else
-extern "C" SEXP _arrow_allocate_arrow_array(){
-	Rf_error("Cannot call allocate_arrow_array(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+	return cpp11::as_sexp(allocate_arrow_array());
+END_CPP11
 }
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void delete_arrow_array(arrow::r::Pointer<struct ArrowArray> ptr);
 extern "C" SEXP _arrow_delete_arrow_array(SEXP ptr_sexp){
 BEGIN_CPP11
@@ -4929,14 +2744,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_delete_arrow_array(SEXP ptr_sexp){
-	Rf_error("Cannot call delete_arrow_array(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void ExportType(const std::shared_ptr<arrow::DataType>& type, arrow::r::Pointer<struct ArrowSchema> ptr);
 extern "C" SEXP _arrow_ExportType(SEXP type_sexp, SEXP ptr_sexp){
 BEGIN_CPP11
@@ -4946,14 +2754,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ExportType(SEXP type_sexp, SEXP ptr_sexp){
-	Rf_error("Cannot call ExportType(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void ExportSchema(const std::shared_ptr<arrow::Schema>& schema, arrow::r::Pointer<struct ArrowSchema> ptr);
 extern "C" SEXP _arrow_ExportSchema(SEXP schema_sexp, SEXP ptr_sexp){
 BEGIN_CPP11
@@ -4963,14 +2764,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ExportSchema(SEXP schema_sexp, SEXP ptr_sexp){
-	Rf_error("Cannot call ExportSchema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void ExportArray(const std::shared_ptr<arrow::Array>& array, arrow::r::Pointer<struct ArrowArray> array_ptr, arrow::r::Pointer<struct ArrowSchema> schema_ptr);
 extern "C" SEXP _arrow_ExportArray(SEXP array_sexp, SEXP array_ptr_sexp, SEXP schema_ptr_sexp){
 BEGIN_CPP11
@@ -4981,14 +2775,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ExportArray(SEXP array_sexp, SEXP array_ptr_sexp, SEXP schema_ptr_sexp){
-	Rf_error("Cannot call ExportArray(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // py-to-r.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void ExportRecordBatch(const std::shared_ptr<arrow::RecordBatch>& batch, arrow::r::Pointer<struct ArrowArray> array_ptr, arrow::r::Pointer<struct ArrowSchema> schema_ptr);
 extern "C" SEXP _arrow_ExportRecordBatch(SEXP batch_sexp, SEXP array_ptr_sexp, SEXP schema_ptr_sexp){
 BEGIN_CPP11
@@ -4999,14 +2786,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ExportRecordBatch(SEXP batch_sexp, SEXP array_ptr_sexp, SEXP schema_ptr_sexp){
-	Rf_error("Cannot call ExportRecordBatch(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int RecordBatch__num_columns(const std::shared_ptr<arrow::RecordBatch>& x);
 extern "C" SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){
 BEGIN_CPP11
@@ -5014,14 +2794,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__num_columns(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){
-	Rf_error("Cannot call RecordBatch__num_columns(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int RecordBatch__num_rows(const std::shared_ptr<arrow::RecordBatch>& x);
 extern "C" SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){
 BEGIN_CPP11
@@ -5029,14 +2802,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__num_rows(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){
-	Rf_error("Cannot call RecordBatch__num_rows(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> RecordBatch__schema(const std::shared_ptr<arrow::RecordBatch>& x);
 extern "C" SEXP _arrow_RecordBatch__schema(SEXP x_sexp){
 BEGIN_CPP11
@@ -5044,14 +2810,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__schema(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__schema(SEXP x_sexp){
-	Rf_error("Cannot call RecordBatch__schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> RecordBatch__RenameColumns(const std::shared_ptr<arrow::RecordBatch>& batch, const std::vector<std::string>& names);
 extern "C" SEXP _arrow_RecordBatch__RenameColumns(SEXP batch_sexp, SEXP names_sexp){
 BEGIN_CPP11
@@ -5060,14 +2819,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__RenameColumns(batch, names));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__RenameColumns(SEXP batch_sexp, SEXP names_sexp){
-	Rf_error("Cannot call RecordBatch__RenameColumns(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> RecordBatch__ReplaceSchemaMetadata(const std::shared_ptr<arrow::RecordBatch>& x, cpp11::strings metadata);
 extern "C" SEXP _arrow_RecordBatch__ReplaceSchemaMetadata(SEXP x_sexp, SEXP metadata_sexp){
 BEGIN_CPP11
@@ -5076,14 +2828,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__ReplaceSchemaMetadata(x, metadata));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__ReplaceSchemaMetadata(SEXP x_sexp, SEXP metadata_sexp){
-	Rf_error("Cannot call RecordBatch__ReplaceSchemaMetadata(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list RecordBatch__columns(const std::shared_ptr<arrow::RecordBatch>& batch);
 extern "C" SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){
 BEGIN_CPP11
@@ -5091,14 +2836,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__columns(batch));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){
-	Rf_error("Cannot call RecordBatch__columns(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> RecordBatch__column(const std::shared_ptr<arrow::RecordBatch>& batch, R_xlen_t i);
 extern "C" SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -5107,14 +2845,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__column(batch, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){
-	Rf_error("Cannot call RecordBatch__column(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Array> RecordBatch__GetColumnByName(const std::shared_ptr<arrow::RecordBatch>& batch, const std::string& name);
 extern "C" SEXP _arrow_RecordBatch__GetColumnByName(SEXP batch_sexp, SEXP name_sexp){
 BEGIN_CPP11
@@ -5123,14 +2854,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__GetColumnByName(batch, name));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__GetColumnByName(SEXP batch_sexp, SEXP name_sexp){
-	Rf_error("Cannot call RecordBatch__GetColumnByName(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> RecordBatch__SelectColumns(const std::shared_ptr<arrow::RecordBatch>& batch, cpp11::integers indices);
 extern "C" SEXP _arrow_RecordBatch__SelectColumns(SEXP batch_sexp, SEXP indices_sexp){
 BEGIN_CPP11
@@ -5139,14 +2863,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__SelectColumns(batch, indices));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__SelectColumns(SEXP batch_sexp, SEXP indices_sexp){
-	Rf_error("Cannot call RecordBatch__SelectColumns(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool RecordBatch__Equals(const std::shared_ptr<arrow::RecordBatch>& self, const std::shared_ptr<arrow::RecordBatch>& other, bool check_metadata);
 extern "C" SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp, SEXP check_metadata_sexp){
 BEGIN_CPP11
@@ -5156,14 +2873,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__Equals(self, other, check_metadata));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp, SEXP check_metadata_sexp){
-	Rf_error("Cannot call RecordBatch__Equals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> RecordBatch__RemoveColumn(const std::shared_ptr<arrow::RecordBatch>& batch, R_xlen_t i);
 extern "C" SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -5172,14 +2882,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__RemoveColumn(batch, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){
-	Rf_error("Cannot call RecordBatch__RemoveColumn(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string RecordBatch__column_name(const std::shared_ptr<arrow::RecordBatch>& batch, R_xlen_t i);
 extern "C" SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -5188,14 +2891,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__column_name(batch, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){
-	Rf_error("Cannot call RecordBatch__column_name(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::writable::strings RecordBatch__names(const std::shared_ptr<arrow::RecordBatch>& batch);
 extern "C" SEXP _arrow_RecordBatch__names(SEXP batch_sexp){
 BEGIN_CPP11
@@ -5203,14 +2899,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__names(batch));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__names(SEXP batch_sexp){
-	Rf_error("Cannot call RecordBatch__names(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> RecordBatch__Slice1(const std::shared_ptr<arrow::RecordBatch>& self, R_xlen_t offset);
 extern "C" SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){
 BEGIN_CPP11
@@ -5219,14 +2908,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__Slice1(self, offset));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){
-	Rf_error("Cannot call RecordBatch__Slice1(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> RecordBatch__Slice2(const std::shared_ptr<arrow::RecordBatch>& self, R_xlen_t offset, R_xlen_t length);
 extern "C" SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){
 BEGIN_CPP11
@@ -5236,14 +2918,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__Slice2(self, offset, length));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){
-	Rf_error("Cannot call RecordBatch__Slice2(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::raws ipc___SerializeRecordBatch__Raw(const std::shared_ptr<arrow::RecordBatch>& batch);
 extern "C" SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){
 BEGIN_CPP11
@@ -5251,14 +2926,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___SerializeRecordBatch__Raw(batch));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){
-	Rf_error("Cannot call ipc___SerializeRecordBatch__Raw(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> ipc___ReadRecordBatch__InputStream__Schema(const std::shared_ptr<arrow::io::InputStream>& stream, const std::shared_ptr<arrow::Schema>& schema);
 extern "C" SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){
 BEGIN_CPP11
@@ -5267,14 +2935,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___ReadRecordBatch__InputStream__Schema(stream, schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){
-	Rf_error("Cannot call ipc___ReadRecordBatch__InputStream__Schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatch.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> RecordBatch__from_arrays(SEXP schema_sxp, SEXP lst);
 extern "C" SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){
 BEGIN_CPP11
@@ -5283,14 +2944,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatch__from_arrays(schema_sxp, lst));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){
-	Rf_error("Cannot call RecordBatch__from_arrays(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> RecordBatchReader__schema(const std::shared_ptr<arrow::RecordBatchReader>& reader);
 extern "C" SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){
 BEGIN_CPP11
@@ -5298,14 +2952,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatchReader__schema(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){
-	Rf_error("Cannot call RecordBatchReader__schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> RecordBatchReader__ReadNext(const std::shared_ptr<arrow::RecordBatchReader>& reader);
 extern "C" SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){
 BEGIN_CPP11
@@ -5313,14 +2960,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(RecordBatchReader__ReadNext(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){
-	Rf_error("Cannot call RecordBatchReader__ReadNext(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ipc::RecordBatchStreamReader> ipc___RecordBatchStreamReader__Open(const std::shared_ptr<arrow::io::InputStream>& stream);
 extern "C" SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){
 BEGIN_CPP11
@@ -5328,14 +2968,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___RecordBatchStreamReader__Open(stream));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){
-	Rf_error("Cannot call ipc___RecordBatchStreamReader__Open(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list ipc___RecordBatchStreamReader__batches(const std::shared_ptr<arrow::ipc::RecordBatchStreamReader>& reader);
 extern "C" SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){
 BEGIN_CPP11
@@ -5343,14 +2976,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___RecordBatchStreamReader__batches(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){
-	Rf_error("Cannot call ipc___RecordBatchStreamReader__batches(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> ipc___RecordBatchFileReader__schema(const std::shared_ptr<arrow::ipc::RecordBatchFileReader>& reader);
 extern "C" SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){
 BEGIN_CPP11
@@ -5358,14 +2984,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___RecordBatchFileReader__schema(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){
-	Rf_error("Cannot call ipc___RecordBatchFileReader__schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int ipc___RecordBatchFileReader__num_record_batches(const std::shared_ptr<arrow::ipc::RecordBatchFileReader>& reader);
 extern "C" SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){
 BEGIN_CPP11
@@ -5373,14 +2992,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___RecordBatchFileReader__num_record_batches(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){
-	Rf_error("Cannot call ipc___RecordBatchFileReader__num_record_batches(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::RecordBatch> ipc___RecordBatchFileReader__ReadRecordBatch(const std::shared_ptr<arrow::ipc::RecordBatchFileReader>& reader, int i);
 extern "C" SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -5389,14 +3001,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___RecordBatchFileReader__ReadRecordBatch(reader, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){
-	Rf_error("Cannot call ipc___RecordBatchFileReader__ReadRecordBatch(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ipc::RecordBatchFileReader> ipc___RecordBatchFileReader__Open(const std::shared_ptr<arrow::io::RandomAccessFile>& file);
 extern "C" SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){
 BEGIN_CPP11
@@ -5404,14 +3009,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___RecordBatchFileReader__Open(file));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){
-	Rf_error("Cannot call ipc___RecordBatchFileReader__Open(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__from_RecordBatchReader(const std::shared_ptr<arrow::RecordBatchReader>& reader);
 extern "C" SEXP _arrow_Table__from_RecordBatchReader(SEXP reader_sexp){
 BEGIN_CPP11
@@ -5419,14 +3017,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__from_RecordBatchReader(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__from_RecordBatchReader(SEXP reader_sexp){
-	Rf_error("Cannot call Table__from_RecordBatchReader(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__from_RecordBatchFileReader(const std::shared_ptr<arrow::ipc::RecordBatchFileReader>& reader);
 extern "C" SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){
 BEGIN_CPP11
@@ -5434,14 +3025,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__from_RecordBatchFileReader(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){
-	Rf_error("Cannot call Table__from_RecordBatchFileReader(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchreader.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list ipc___RecordBatchFileReader__batches(const std::shared_ptr<arrow::ipc::RecordBatchFileReader>& reader);
 extern "C" SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){
 BEGIN_CPP11
@@ -5449,14 +3033,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___RecordBatchFileReader__batches(reader));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){
-	Rf_error("Cannot call ipc___RecordBatchFileReader__batches(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchwriter.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void ipc___RecordBatchWriter__WriteRecordBatch(const std::shared_ptr<arrow::ipc::RecordBatchWriter>& batch_writer, const std::shared_ptr<arrow::RecordBatch>& batch);
 extern "C" SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){
 BEGIN_CPP11
@@ -5466,14 +3043,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){
-	Rf_error("Cannot call ipc___RecordBatchWriter__WriteRecordBatch(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchwriter.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void ipc___RecordBatchWriter__WriteTable(const std::shared_ptr<arrow::ipc::RecordBatchWriter>& batch_writer, const std::shared_ptr<arrow::Table>& table);
 extern "C" SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){
 BEGIN_CPP11
@@ -5483,14 +3053,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){
-	Rf_error("Cannot call ipc___RecordBatchWriter__WriteTable(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchwriter.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void ipc___RecordBatchWriter__Close(const std::shared_ptr<arrow::ipc::RecordBatchWriter>& batch_writer);
 extern "C" SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){
 BEGIN_CPP11
@@ -5499,14 +3062,7 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){
-	Rf_error("Cannot call ipc___RecordBatchWriter__Close(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchwriter.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ipc::RecordBatchWriter> ipc___RecordBatchFileWriter__Open(const std::shared_ptr<arrow::io::OutputStream>& stream, const std::shared_ptr<arrow::Schema>& schema, bool use_legacy_format, arrow::ipc::MetadataVersion metadata_version);
 extern "C" SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp, SEXP use_legacy_format_sexp, SEXP metadata_version_sexp){
 BEGIN_CPP11
@@ -5517,14 +3073,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___RecordBatchFileWriter__Open(stream, schema, use_legacy_format, metadata_version));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp, SEXP use_legacy_format_sexp, SEXP metadata_version_sexp){
-	Rf_error("Cannot call ipc___RecordBatchFileWriter__Open(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // recordbatchwriter.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ipc::RecordBatchWriter> ipc___RecordBatchStreamWriter__Open(const std::shared_ptr<arrow::io::OutputStream>& stream, const std::shared_ptr<arrow::Schema>& schema, bool use_legacy_format, arrow::ipc::MetadataVersion metadata_version);
 extern "C" SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp, SEXP use_legacy_format_sexp, SEXP metadata_version_sexp){
 BEGIN_CPP11
@@ -5535,14 +3084,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(ipc___RecordBatchStreamWriter__Open(stream, schema, use_legacy_format, metadata_version));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp, SEXP use_legacy_format_sexp, SEXP metadata_version_sexp){
-	Rf_error("Cannot call ipc___RecordBatchStreamWriter__Open(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // scalar.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Scalar> Array__GetScalar(const std::shared_ptr<arrow::Array>& x, int64_t i);
 extern "C" SEXP _arrow_Array__GetScalar(SEXP x_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -5551,14 +3093,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Array__GetScalar(x, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Array__GetScalar(SEXP x_sexp, SEXP i_sexp){
-	Rf_error("Cannot call Array__GetScalar(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // scalar.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string Scalar__ToString(const std::shared_ptr<arrow::Scalar>& s);
 extern "C" SEXP _arrow_Scalar__ToString(SEXP s_sexp){
 BEGIN_CPP11
@@ -5566,14 +3101,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Scalar__ToString(s));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Scalar__ToString(SEXP s_sexp){
-	Rf_error("Cannot call Scalar__ToString(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // scalar.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Scalar> StructScalar__field(const std::shared_ptr<arrow::StructScalar>& s, int i);
 extern "C" SEXP _arrow_StructScalar__field(SEXP s_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -5582,14 +3110,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(StructScalar__field(s, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_StructScalar__field(SEXP s_sexp, SEXP i_sexp){
-	Rf_error("Cannot call StructScalar__field(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // scalar.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Scalar> StructScalar__GetFieldByName(const std::shared_ptr<arrow::StructScalar>& s, const std::string& name);
 extern "C" SEXP _arrow_StructScalar__GetFieldByName(SEXP s_sexp, SEXP name_sexp){
 BEGIN_CPP11
@@ -5598,14 +3119,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(StructScalar__GetFieldByName(s, name));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_StructScalar__GetFieldByName(SEXP s_sexp, SEXP name_sexp){
-	Rf_error("Cannot call StructScalar__GetFieldByName(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // scalar.cpp
-#if defined(ARROW_R_WITH_ARROW)
 SEXP Scalar__as_vector(const std::shared_ptr<arrow::Scalar>& scalar);
 extern "C" SEXP _arrow_Scalar__as_vector(SEXP scalar_sexp){
 BEGIN_CPP11
@@ -5613,14 +3127,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Scalar__as_vector(scalar));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Scalar__as_vector(SEXP scalar_sexp){
-	Rf_error("Cannot call Scalar__as_vector(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // scalar.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Scalar__is_valid(const std::shared_ptr<arrow::Scalar>& s);
 extern "C" SEXP _arrow_Scalar__is_valid(SEXP s_sexp){
 BEGIN_CPP11
@@ -5628,14 +3135,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Scalar__is_valid(s));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Scalar__is_valid(SEXP s_sexp){
-	Rf_error("Cannot call Scalar__is_valid(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // scalar.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> Scalar__type(const std::shared_ptr<arrow::Scalar>& s);
 extern "C" SEXP _arrow_Scalar__type(SEXP s_sexp){
 BEGIN_CPP11
@@ -5643,14 +3143,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Scalar__type(s));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Scalar__type(SEXP s_sexp){
-	Rf_error("Cannot call Scalar__type(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> schema_(const std::vector<std::shared_ptr<arrow::Field>>& fields);
 extern "C" SEXP _arrow_schema_(SEXP fields_sexp){
 BEGIN_CPP11
@@ -5658,14 +3151,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(schema_(fields));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_schema_(SEXP fields_sexp){
-	Rf_error("Cannot call schema_(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::string Schema__ToString(const std::shared_ptr<arrow::Schema>& s);
 extern "C" SEXP _arrow_Schema__ToString(SEXP s_sexp){
 BEGIN_CPP11
@@ -5673,14 +3159,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__ToString(s));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__ToString(SEXP s_sexp){
-	Rf_error("Cannot call Schema__ToString(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int Schema__num_fields(const std::shared_ptr<arrow::Schema>& s);
 extern "C" SEXP _arrow_Schema__num_fields(SEXP s_sexp){
 BEGIN_CPP11
@@ -5688,14 +3167,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__num_fields(s));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__num_fields(SEXP s_sexp){
-	Rf_error("Cannot call Schema__num_fields(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Field> Schema__field(const std::shared_ptr<arrow::Schema>& s, int i);
 extern "C" SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -5704,14 +3176,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__field(s, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){
-	Rf_error("Cannot call Schema__field(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Field> Schema__GetFieldByName(const std::shared_ptr<arrow::Schema>& s, std::string x);
 extern "C" SEXP _arrow_Schema__GetFieldByName(SEXP s_sexp, SEXP x_sexp){
 BEGIN_CPP11
@@ -5720,14 +3185,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__GetFieldByName(s, x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__GetFieldByName(SEXP s_sexp, SEXP x_sexp){
-	Rf_error("Cannot call Schema__GetFieldByName(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list Schema__fields(const std::shared_ptr<arrow::Schema>& schema);
 extern "C" SEXP _arrow_Schema__fields(SEXP schema_sexp){
 BEGIN_CPP11
@@ -5735,14 +3193,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__fields(schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__fields(SEXP schema_sexp){
-	Rf_error("Cannot call Schema__fields(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::vector<std::string> Schema__field_names(const std::shared_ptr<arrow::Schema>& schema);
 extern "C" SEXP _arrow_Schema__field_names(SEXP schema_sexp){
 BEGIN_CPP11
@@ -5750,14 +3201,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__field_names(schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__field_names(SEXP schema_sexp){
-	Rf_error("Cannot call Schema__field_names(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Schema__HasMetadata(const std::shared_ptr<arrow::Schema>& schema);
 extern "C" SEXP _arrow_Schema__HasMetadata(SEXP schema_sexp){
 BEGIN_CPP11
@@ -5765,14 +3209,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__HasMetadata(schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__HasMetadata(SEXP schema_sexp){
-	Rf_error("Cannot call Schema__HasMetadata(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::writable::list Schema__metadata(const std::shared_ptr<arrow::Schema>& schema);
 extern "C" SEXP _arrow_Schema__metadata(SEXP schema_sexp){
 BEGIN_CPP11
@@ -5780,14 +3217,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__metadata(schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__metadata(SEXP schema_sexp){
-	Rf_error("Cannot call Schema__metadata(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> Schema__WithMetadata(const std::shared_ptr<arrow::Schema>& schema, cpp11::strings metadata);
 extern "C" SEXP _arrow_Schema__WithMetadata(SEXP schema_sexp, SEXP metadata_sexp){
 BEGIN_CPP11
@@ -5796,14 +3226,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__WithMetadata(schema, metadata));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__WithMetadata(SEXP schema_sexp, SEXP metadata_sexp){
-	Rf_error("Cannot call Schema__WithMetadata(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::writable::raws Schema__serialize(const std::shared_ptr<arrow::Schema>& schema);
 extern "C" SEXP _arrow_Schema__serialize(SEXP schema_sexp){
 BEGIN_CPP11
@@ -5811,14 +3234,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__serialize(schema));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__serialize(SEXP schema_sexp){
-	Rf_error("Cannot call Schema__serialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Schema__Equals(const std::shared_ptr<arrow::Schema>& schema, const std::shared_ptr<arrow::Schema>& other, bool check_metadata);
 extern "C" SEXP _arrow_Schema__Equals(SEXP schema_sexp, SEXP other_sexp, SEXP check_metadata_sexp){
 BEGIN_CPP11
@@ -5828,14 +3244,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Schema__Equals(schema, other, check_metadata));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Schema__Equals(SEXP schema_sexp, SEXP other_sexp, SEXP check_metadata_sexp){
-	Rf_error("Cannot call Schema__Equals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // schema.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> arrow__UnifySchemas(const std::vector<std::shared_ptr<arrow::Schema>>& schemas);
 extern "C" SEXP _arrow_arrow__UnifySchemas(SEXP schemas_sexp){
 BEGIN_CPP11
@@ -5843,14 +3252,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(arrow__UnifySchemas(schemas));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_arrow__UnifySchemas(SEXP schemas_sexp){
-	Rf_error("Cannot call arrow__UnifySchemas(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int Table__num_columns(const std::shared_ptr<arrow::Table>& x);
 extern "C" SEXP _arrow_Table__num_columns(SEXP x_sexp){
 BEGIN_CPP11
@@ -5858,14 +3260,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__num_columns(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__num_columns(SEXP x_sexp){
-	Rf_error("Cannot call Table__num_columns(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int Table__num_rows(const std::shared_ptr<arrow::Table>& x);
 extern "C" SEXP _arrow_Table__num_rows(SEXP x_sexp){
 BEGIN_CPP11
@@ -5873,14 +3268,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__num_rows(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__num_rows(SEXP x_sexp){
-	Rf_error("Cannot call Table__num_rows(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Schema> Table__schema(const std::shared_ptr<arrow::Table>& x);
 extern "C" SEXP _arrow_Table__schema(SEXP x_sexp){
 BEGIN_CPP11
@@ -5888,14 +3276,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__schema(x));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__schema(SEXP x_sexp){
-	Rf_error("Cannot call Table__schema(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__ReplaceSchemaMetadata(const std::shared_ptr<arrow::Table>& x, cpp11::strings metadata);
 extern "C" SEXP _arrow_Table__ReplaceSchemaMetadata(SEXP x_sexp, SEXP metadata_sexp){
 BEGIN_CPP11
@@ -5904,14 +3285,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__ReplaceSchemaMetadata(x, metadata));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__ReplaceSchemaMetadata(SEXP x_sexp, SEXP metadata_sexp){
-	Rf_error("Cannot call Table__ReplaceSchemaMetadata(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ChunkedArray> Table__column(const std::shared_ptr<arrow::Table>& table, R_xlen_t i);
 extern "C" SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -5920,14 +3294,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__column(table, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){
-	Rf_error("Cannot call Table__column(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Field> Table__field(const std::shared_ptr<arrow::Table>& table, R_xlen_t i);
 extern "C" SEXP _arrow_Table__field(SEXP table_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -5936,14 +3303,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__field(table, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__field(SEXP table_sexp, SEXP i_sexp){
-	Rf_error("Cannot call Table__field(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 cpp11::list Table__columns(const std::shared_ptr<arrow::Table>& table);
 extern "C" SEXP _arrow_Table__columns(SEXP table_sexp){
 BEGIN_CPP11
@@ -5951,14 +3311,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__columns(table));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__columns(SEXP table_sexp){
-	Rf_error("Cannot call Table__columns(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::vector<std::string> Table__ColumnNames(const std::shared_ptr<arrow::Table>& table);
 extern "C" SEXP _arrow_Table__ColumnNames(SEXP table_sexp){
 BEGIN_CPP11
@@ -5966,14 +3319,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__ColumnNames(table));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__ColumnNames(SEXP table_sexp){
-	Rf_error("Cannot call Table__ColumnNames(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__RenameColumns(const std::shared_ptr<arrow::Table>& table, const std::vector<std::string>& names);
 extern "C" SEXP _arrow_Table__RenameColumns(SEXP table_sexp, SEXP names_sexp){
 BEGIN_CPP11
@@ -5982,14 +3328,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__RenameColumns(table, names));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__RenameColumns(SEXP table_sexp, SEXP names_sexp){
-	Rf_error("Cannot call Table__RenameColumns(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__Slice1(const std::shared_ptr<arrow::Table>& table, R_xlen_t offset);
 extern "C" SEXP _arrow_Table__Slice1(SEXP table_sexp, SEXP offset_sexp){
 BEGIN_CPP11
@@ -5998,14 +3337,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__Slice1(table, offset));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__Slice1(SEXP table_sexp, SEXP offset_sexp){
-	Rf_error("Cannot call Table__Slice1(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__Slice2(const std::shared_ptr<arrow::Table>& table, R_xlen_t offset, R_xlen_t length);
 extern "C" SEXP _arrow_Table__Slice2(SEXP table_sexp, SEXP offset_sexp, SEXP length_sexp){
 BEGIN_CPP11
@@ -6015,14 +3347,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__Slice2(table, offset, length));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__Slice2(SEXP table_sexp, SEXP offset_sexp, SEXP length_sexp){
-	Rf_error("Cannot call Table__Slice2(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Table__Equals(const std::shared_ptr<arrow::Table>& lhs, const std::shared_ptr<arrow::Table>& rhs, bool check_metadata);
 extern "C" SEXP _arrow_Table__Equals(SEXP lhs_sexp, SEXP rhs_sexp, SEXP check_metadata_sexp){
 BEGIN_CPP11
@@ -6032,14 +3357,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__Equals(lhs, rhs, check_metadata));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__Equals(SEXP lhs_sexp, SEXP rhs_sexp, SEXP check_metadata_sexp){
-	Rf_error("Cannot call Table__Equals(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Table__Validate(const std::shared_ptr<arrow::Table>& table);
 extern "C" SEXP _arrow_Table__Validate(SEXP table_sexp){
 BEGIN_CPP11
@@ -6047,14 +3365,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__Validate(table));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__Validate(SEXP table_sexp){
-	Rf_error("Cannot call Table__Validate(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool Table__ValidateFull(const std::shared_ptr<arrow::Table>& table);
 extern "C" SEXP _arrow_Table__ValidateFull(SEXP table_sexp){
 BEGIN_CPP11
@@ -6062,14 +3373,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__ValidateFull(table));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__ValidateFull(SEXP table_sexp){
-	Rf_error("Cannot call Table__ValidateFull(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::ChunkedArray> Table__GetColumnByName(const std::shared_ptr<arrow::Table>& table, const std::string& name);
 extern "C" SEXP _arrow_Table__GetColumnByName(SEXP table_sexp, SEXP name_sexp){
 BEGIN_CPP11
@@ -6078,14 +3382,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__GetColumnByName(table, name));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__GetColumnByName(SEXP table_sexp, SEXP name_sexp){
-	Rf_error("Cannot call Table__GetColumnByName(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__RemoveColumn(const std::shared_ptr<arrow::Table>& table, R_xlen_t i);
 extern "C" SEXP _arrow_Table__RemoveColumn(SEXP table_sexp, SEXP i_sexp){
 BEGIN_CPP11
@@ -6094,14 +3391,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__RemoveColumn(table, i));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__RemoveColumn(SEXP table_sexp, SEXP i_sexp){
-	Rf_error("Cannot call Table__RemoveColumn(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__AddColumn(const std::shared_ptr<arrow::Table>& table, R_xlen_t i, const std::shared_ptr<arrow::Field>& field, const std::shared_ptr<arrow::ChunkedArray>& column);
 extern "C" SEXP _arrow_Table__AddColumn(SEXP table_sexp, SEXP i_sexp, SEXP field_sexp, SEXP column_sexp){
 BEGIN_CPP11
@@ -6112,14 +3402,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__AddColumn(table, i, field, column));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__AddColumn(SEXP table_sexp, SEXP i_sexp, SEXP field_sexp, SEXP column_sexp){
-	Rf_error("Cannot call Table__AddColumn(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__SetColumn(const std::shared_ptr<arrow::Table>& table, R_xlen_t i, const std::shared_ptr<arrow::Field>& field, const std::shared_ptr<arrow::ChunkedArray>& column);
 extern "C" SEXP _arrow_Table__SetColumn(SEXP table_sexp, SEXP i_sexp, SEXP field_sexp, SEXP column_sexp){
 BEGIN_CPP11
@@ -6130,14 +3413,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__SetColumn(table, i, field, column));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__SetColumn(SEXP table_sexp, SEXP i_sexp, SEXP field_sexp, SEXP column_sexp){
-	Rf_error("Cannot call Table__SetColumn(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__SelectColumns(const std::shared_ptr<arrow::Table>& table, const std::vector<int>& indices);
 extern "C" SEXP _arrow_Table__SelectColumns(SEXP table_sexp, SEXP indices_sexp){
 BEGIN_CPP11
@@ -6146,14 +3422,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__SelectColumns(table, indices));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__SelectColumns(SEXP table_sexp, SEXP indices_sexp){
-	Rf_error("Cannot call Table__SelectColumns(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 bool all_record_batches(SEXP lst);
 extern "C" SEXP _arrow_all_record_batches(SEXP lst_sexp){
 BEGIN_CPP11
@@ -6161,14 +3430,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(all_record_batches(lst));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_all_record_batches(SEXP lst_sexp){
-	Rf_error("Cannot call all_record_batches(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__from_record_batches(const std::vector<std::shared_ptr<arrow::RecordBatch>>& batches, SEXP schema_sxp);
 extern "C" SEXP _arrow_Table__from_record_batches(SEXP batches_sexp, SEXP schema_sxp_sexp){
 BEGIN_CPP11
@@ -6177,14 +3439,7 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__from_record_batches(batches, schema_sxp));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__from_record_batches(SEXP batches_sexp, SEXP schema_sxp_sexp){
-	Rf_error("Cannot call Table__from_record_batches(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // table.cpp
-#if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::Table> Table__from_dots(SEXP lst, SEXP schema_sxp);
 extern "C" SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){
 BEGIN_CPP11
@@ -6193,28 +3448,14 @@ BEGIN_CPP11
 	return cpp11::as_sexp(Table__from_dots(lst, schema_sxp));
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){
-	Rf_error("Cannot call Table__from_dots(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // threadpool.cpp
-#if defined(ARROW_R_WITH_ARROW)
 int GetCpuThreadPoolCapacity();
 extern "C" SEXP _arrow_GetCpuThreadPoolCapacity(){
 BEGIN_CPP11
 	return cpp11::as_sexp(GetCpuThreadPoolCapacity());
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_GetCpuThreadPoolCapacity(){
-	Rf_error("Cannot call GetCpuThreadPoolCapacity(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 // threadpool.cpp
-#if defined(ARROW_R_WITH_ARROW)
 void SetCpuThreadPoolCapacity(int threads);
 extern "C" SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){
 BEGIN_CPP11
@@ -6223,38 +3464,18 @@ BEGIN_CPP11
 	return R_NilValue;
 END_CPP11
 }
-#else
-extern "C" SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){
-	Rf_error("Cannot call SetCpuThreadPoolCapacity(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
-#if defined(ARROW_R_WITH_ARROW)
 extern "C" SEXP _arrow_Table__Reset(SEXP r6) {
 BEGIN_CPP11
 arrow::r::r6_reset_pointer<arrow::Table>(r6);
 END_CPP11
 return R_NilValue;
 }
-#else
-extern "C" SEXP _arrow_Table__Reset(SEXP r6){
-	Rf_error("Cannot call Table(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
-#if defined(ARROW_R_WITH_ARROW)
 extern "C" SEXP _arrow_RecordBatch__Reset(SEXP r6) {
 BEGIN_CPP11
 arrow::r::r6_reset_pointer<arrow::RecordBatch>(r6);
 END_CPP11
 return R_NilValue;
 }
-#else
-extern "C" SEXP _arrow_RecordBatch__Reset(SEXP r6){
-	Rf_error("Cannot call RecordBatch(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
-}
-#endif
-
 
 extern "C" SEXP _arrow_available() {
 return Rf_ScalarLogical(