r/R/arrowExports.R

# Generated by using data-raw/codegen.R -> do not edit by hand

Array__Slice1 <- function(array, offset){
    .Call(`_arrow_Array__Slice1` , array, offset)
}

Array__Slice2 <- function(array, offset, length){
    .Call(`_arrow_Array__Slice2` , array, offset, length)
}

Array__IsNull <- function(x, i){
    .Call(`_arrow_Array__IsNull` , x, i)
}

Array__IsValid <- function(x, i){
    .Call(`_arrow_Array__IsValid` , x, i)
}

Array__length <- function(x){
    .Call(`_arrow_Array__length` , x)
}

Array__offset <- function(x){
    .Call(`_arrow_Array__offset` , x)
}

Array__null_count <- function(x){
    .Call(`_arrow_Array__null_count` , x)
}

Array__type <- function(x){
    .Call(`_arrow_Array__type` , x)
}

Array__ToString <- function(x){
    .Call(`_arrow_Array__ToString` , x)
}

Array__type_id <- function(x){
    .Call(`_arrow_Array__type_id` , x)
}

Array__Equals <- function(lhs, rhs){
    .Call(`_arrow_Array__Equals` , lhs, rhs)
}

Array__ApproxEquals <- function(lhs, rhs){
    .Call(`_arrow_Array__ApproxEquals` , lhs, rhs)
}

Array__data <- function(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)
}

Array__Mask <- function(array){
    .Call(`_arrow_Array__Mask` , array)
}

DictionaryArray__indices <- function(array){
    .Call(`_arrow_DictionaryArray__indices` , array)
}

DictionaryArray__dictionary <- function(array){
    .Call(`_arrow_DictionaryArray__dictionary` , array)
}

StructArray__field <- function(array, i){
    .Call(`_arrow_StructArray__field` , array, i)
}

StructArray__GetFieldByName <- function(array, name){
    .Call(`_arrow_StructArray__GetFieldByName` , array, name)
}

StructArray__Flatten <- function(array){
    .Call(`_arrow_StructArray__Flatten` , array)
}

ListArray__value_type <- function(array){
    .Call(`_arrow_ListArray__value_type` , array)
}

ListArray__values <- function(array){
    .Call(`_arrow_ListArray__values` , array)
}

ListArray__value_length <- function(array, i){
    .Call(`_arrow_ListArray__value_length` , array, i)
}

ListArray__value_offset <- function(array, i){
    .Call(`_arrow_ListArray__value_offset` , array, i)
}

ListArray__raw_value_offsets <- function(array){
    .Call(`_arrow_ListArray__raw_value_offsets` , array)
}

Array__as_vector <- function(array){
    .Call(`_arrow_Array__as_vector` , array)
}

ChunkedArray__as_vector <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__as_vector` , chunked_array)
}

RecordBatch__to_dataframe <- function(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)
}

Array__infer_type <- function(x){
    .Call(`_arrow_Array__infer_type` , x)
}

Array__from_vector <- function(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)
}

ArrayData__get_type <- function(x){
    .Call(`_arrow_ArrayData__get_type` , x)
}

ArrayData__get_length <- function(x){
    .Call(`_arrow_ArrayData__get_length` , x)
}

ArrayData__get_null_count <- function(x){
    .Call(`_arrow_ArrayData__get_null_count` , x)
}

ArrayData__get_offset <- function(x){
    .Call(`_arrow_ArrayData__get_offset` , x)
}

ArrayData__buffers <- function(x){
    .Call(`_arrow_ArrayData__buffers` , x)
}

Buffer__is_mutable <- function(buffer){
    .Call(`_arrow_Buffer__is_mutable` , buffer)
}

Buffer__ZeroPadding <- function(buffer){
    invisible(.Call(`_arrow_Buffer__ZeroPadding` , buffer))
}

Buffer__capacity <- function(buffer){
    .Call(`_arrow_Buffer__capacity` , buffer)
}

Buffer__size <- function(buffer){
    .Call(`_arrow_Buffer__size` , buffer)
}

r___RBuffer__initialize <- function(x){
    .Call(`_arrow_r___RBuffer__initialize` , x)
}

Buffer__data <- function(buffer){
    .Call(`_arrow_Buffer__data` , buffer)
}

ChunkedArray__length <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__length` , chunked_array)
}

ChunkedArray__null_count <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__null_count` , chunked_array)
}

ChunkedArray__num_chunks <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__num_chunks` , chunked_array)
}

ChunkedArray__chunk <- function(chunked_array, i){
    .Call(`_arrow_ChunkedArray__chunk` , chunked_array, i)
}

ChunkedArray__chunks <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__chunks` , chunked_array)
}

ChunkedArray__type <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__type` , chunked_array)
}

ChunkArray__Slice1 <- function(chunked_array, offset){
    .Call(`_arrow_ChunkArray__Slice1` , chunked_array, offset)
}

ChunkArray__Slice2 <- function(chunked_array, offset, length){
    .Call(`_arrow_ChunkArray__Slice2` , chunked_array, offset, length)
}

Column__length <- function(column){
    .Call(`_arrow_Column__length` , column)
}

Column__null_count <- function(column){
    .Call(`_arrow_Column__null_count` , column)
}

Column__type <- function(column){
    .Call(`_arrow_Column__type` , column)
}

Column__data <- function(column){
    .Call(`_arrow_Column__data` , column)
}

util___Codec__Create <- function(codec){
    .Call(`_arrow_util___Codec__Create` , codec)
}

io___CompressedOutputStream__Make <- function(codec, raw){
    .Call(`_arrow_io___CompressedOutputStream__Make` , codec, raw)
}

io___CompressedInputStream__Make <- function(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)
}

Array__cast <- function(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)
}

RecordBatch__cast <- function(batch, schema, options){
    .Call(`_arrow_RecordBatch__cast` , batch, schema, options)
}

Table__cast <- function(table, schema, options){
    .Call(`_arrow_Table__cast` , table, schema, options)
}

csv___ReadOptions__initialize <- function(options){
    .Call(`_arrow_csv___ReadOptions__initialize` , options)
}

csv___ParseOptions__initialize <- function(options){
    .Call(`_arrow_csv___ParseOptions__initialize` , options)
}

csv___ConvertOptions__initialize <- function(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)
}

csv___TableReader__Read <- function(table_reader){
    .Call(`_arrow_csv___TableReader__Read` , table_reader)
}

shared_ptr_is_null <- function(xp){
    .Call(`_arrow_shared_ptr_is_null` , xp)
}

unique_ptr_is_null <- function(xp){
    .Call(`_arrow_unique_ptr_is_null` , xp)
}

Int8__initialize <- function(){
    .Call(`_arrow_Int8__initialize` )
}

Int16__initialize <- function(){
    .Call(`_arrow_Int16__initialize` )
}

Int32__initialize <- function(){
    .Call(`_arrow_Int32__initialize` )
}

Int64__initialize <- function(){
    .Call(`_arrow_Int64__initialize` )
}

UInt8__initialize <- function(){
    .Call(`_arrow_UInt8__initialize` )
}

UInt16__initialize <- function(){
    .Call(`_arrow_UInt16__initialize` )
}

UInt32__initialize <- function(){
    .Call(`_arrow_UInt32__initialize` )
}

UInt64__initialize <- function(){
    .Call(`_arrow_UInt64__initialize` )
}

Float16__initialize <- function(){
    .Call(`_arrow_Float16__initialize` )
}

Float32__initialize <- function(){
    .Call(`_arrow_Float32__initialize` )
}

Float64__initialize <- function(){
    .Call(`_arrow_Float64__initialize` )
}

Boolean__initialize <- function(){
    .Call(`_arrow_Boolean__initialize` )
}

Utf8__initialize <- function(){
    .Call(`_arrow_Utf8__initialize` )
}

Date32__initialize <- function(){
    .Call(`_arrow_Date32__initialize` )
}

Date64__initialize <- function(){
    .Call(`_arrow_Date64__initialize` )
}

Null__initialize <- function(){
    .Call(`_arrow_Null__initialize` )
}

Decimal128Type__initialize <- function(precision, scale){
    .Call(`_arrow_Decimal128Type__initialize` , precision, scale)
}

FixedSizeBinary__initialize <- function(byte_width){
    .Call(`_arrow_FixedSizeBinary__initialize` , byte_width)
}

Timestamp__initialize1 <- function(unit){
    .Call(`_arrow_Timestamp__initialize1` , unit)
}

Timestamp__initialize2 <- function(unit, timezone){
    .Call(`_arrow_Timestamp__initialize2` , unit, timezone)
}

Time32__initialize <- function(unit){
    .Call(`_arrow_Time32__initialize` , unit)
}

Time64__initialize <- function(unit){
    .Call(`_arrow_Time64__initialize` , unit)
}

list__ <- function(x){
    .Call(`_arrow_list__` , x)
}

struct_ <- function(fields){
    .Call(`_arrow_struct_` , fields)
}

DataType__ToString <- function(type){
    .Call(`_arrow_DataType__ToString` , type)
}

DataType__name <- function(type){
    .Call(`_arrow_DataType__name` , type)
}

DataType__Equals <- function(lhs, rhs){
    .Call(`_arrow_DataType__Equals` , lhs, rhs)
}

DataType__num_children <- function(type){
    .Call(`_arrow_DataType__num_children` , type)
}

DataType__children_pointer <- function(type){
    .Call(`_arrow_DataType__children_pointer` , type)
}

DataType__id <- function(type){
    .Call(`_arrow_DataType__id` , type)
}

ListType__ToString <- function(type){
    .Call(`_arrow_ListType__ToString` , type)
}

FixedWidthType__bit_width <- function(type){
    .Call(`_arrow_FixedWidthType__bit_width` , type)
}

DateType__unit <- function(type){
    .Call(`_arrow_DateType__unit` , type)
}

TimeType__unit <- function(type){
    .Call(`_arrow_TimeType__unit` , type)
}

DecimalType__precision <- function(type){
    .Call(`_arrow_DecimalType__precision` , type)
}

DecimalType__scale <- function(type){
    .Call(`_arrow_DecimalType__scale` , type)
}

TimestampType__timezone <- function(type){
    .Call(`_arrow_TimestampType__timezone` , type)
}

TimestampType__unit <- function(type){
    .Call(`_arrow_TimestampType__unit` , type)
}

DictionaryType__initialize <- function(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)
}

DictionaryType__value_type <- function(type){
    .Call(`_arrow_DictionaryType__value_type` , type)
}

DictionaryType__name <- function(type){
    .Call(`_arrow_DictionaryType__name` , type)
}

DictionaryType__ordered <- function(type){
    .Call(`_arrow_DictionaryType__ordered` , type)
}

StructType__GetFieldByName <- function(type, name){
    .Call(`_arrow_StructType__GetFieldByName` , type, name)
}

StructType__GetFieldIndex <- function(type, name){
    .Call(`_arrow_StructType__GetFieldIndex` , type, name)
}

ListType__value_field <- function(type){
    .Call(`_arrow_ListType__value_field` , type)
}

ListType__value_type <- function(type){
    .Call(`_arrow_ListType__value_type` , type)
}

ipc___feather___TableWriter__SetDescription <- function(writer, description){
    invisible(.Call(`_arrow_ipc___feather___TableWriter__SetDescription` , writer, description))
}

ipc___feather___TableWriter__SetNumRows <- function(writer, num_rows){
    invisible(.Call(`_arrow_ipc___feather___TableWriter__SetNumRows` , writer, num_rows))
}

ipc___feather___TableWriter__Append <- function(writer, name, values){
    invisible(.Call(`_arrow_ipc___feather___TableWriter__Append` , writer, name, values))
}

ipc___feather___TableWriter__Finalize <- function(writer){
    invisible(.Call(`_arrow_ipc___feather___TableWriter__Finalize` , writer))
}

ipc___feather___TableWriter__Open <- function(stream){
    .Call(`_arrow_ipc___feather___TableWriter__Open` , stream)
}

ipc___TableWriter__RecordBatch__WriteFeather <- function(writer, batch){
    invisible(.Call(`_arrow_ipc___TableWriter__RecordBatch__WriteFeather` , writer, batch))
}

ipc___feather___TableReader__GetDescription <- function(reader){
    .Call(`_arrow_ipc___feather___TableReader__GetDescription` , reader)
}

ipc___feather___TableReader__HasDescription <- function(reader){
    .Call(`_arrow_ipc___feather___TableReader__HasDescription` , reader)
}

ipc___feather___TableReader__version <- function(reader){
    .Call(`_arrow_ipc___feather___TableReader__version` , reader)
}

ipc___feather___TableReader__num_rows <- function(reader){
    .Call(`_arrow_ipc___feather___TableReader__num_rows` , reader)
}

ipc___feather___TableReader__num_columns <- function(reader){
    .Call(`_arrow_ipc___feather___TableReader__num_columns` , reader)
}

ipc___feather___TableReader__GetColumnName <- function(reader, i){
    .Call(`_arrow_ipc___feather___TableReader__GetColumnName` , reader, i)
}

ipc___feather___TableReader__GetColumn <- function(reader, i){
    .Call(`_arrow_ipc___feather___TableReader__GetColumn` , reader, i)
}

ipc___feather___TableReader__Read <- function(reader, columns){
    .Call(`_arrow_ipc___feather___TableReader__Read` , reader, columns)
}

ipc___feather___TableReader__Open <- function(stream){
    .Call(`_arrow_ipc___feather___TableReader__Open` , stream)
}

ipc___feather___TableReader__column_names <- function(reader){
    .Call(`_arrow_ipc___feather___TableReader__column_names` , reader)
}

Field__initialize <- function(name, field, nullable){
    .Call(`_arrow_Field__initialize` , name, field, nullable)
}

Field__ToString <- function(field){
    .Call(`_arrow_Field__ToString` , field)
}

Field__name <- function(field){
    .Call(`_arrow_Field__name` , field)
}

Field__Equals <- function(field, other){
    .Call(`_arrow_Field__Equals` , field, other)
}

Field__nullable <- function(field){
    .Call(`_arrow_Field__nullable` , field)
}

Field__type <- function(field){
    .Call(`_arrow_Field__type` , field)
}

io___Readable__Read <- function(x, nbytes){
    .Call(`_arrow_io___Readable__Read` , x, nbytes)
}

io___InputStream__Close <- function(x){
    invisible(.Call(`_arrow_io___InputStream__Close` , x))
}

io___OutputStream__Close <- function(x){
    invisible(.Call(`_arrow_io___OutputStream__Close` , x))
}

io___RandomAccessFile__GetSize <- function(x){
    .Call(`_arrow_io___RandomAccessFile__GetSize` , x)
}

io___RandomAccessFile__supports_zero_copy <- function(x){
    .Call(`_arrow_io___RandomAccessFile__supports_zero_copy` , x)
}

io___RandomAccessFile__Seek <- function(x, position){
    invisible(.Call(`_arrow_io___RandomAccessFile__Seek` , x, position))
}

io___RandomAccessFile__Tell <- function(x){
    .Call(`_arrow_io___RandomAccessFile__Tell` , x)
}

io___RandomAccessFile__Read0 <- function(x){
    .Call(`_arrow_io___RandomAccessFile__Read0` , x)
}

io___RandomAccessFile__ReadAt <- function(x, position, nbytes){
    .Call(`_arrow_io___RandomAccessFile__ReadAt` , x, position, nbytes)
}

io___MemoryMappedFile__Create <- function(path, size){
    .Call(`_arrow_io___MemoryMappedFile__Create` , path, size)
}

io___MemoryMappedFile__Open <- function(path, mode){
    .Call(`_arrow_io___MemoryMappedFile__Open` , path, mode)
}

io___MemoryMappedFile__Resize <- function(x, size){
    invisible(.Call(`_arrow_io___MemoryMappedFile__Resize` , x, size))
}

io___ReadableFile__Open <- function(path){
    .Call(`_arrow_io___ReadableFile__Open` , path)
}

io___BufferReader__initialize <- function(buffer){
    .Call(`_arrow_io___BufferReader__initialize` , buffer)
}

io___Writable__write <- function(stream, buf){
    invisible(.Call(`_arrow_io___Writable__write` , stream, buf))
}

io___OutputStream__Tell <- function(stream){
    .Call(`_arrow_io___OutputStream__Tell` , stream)
}

io___FileOutputStream__Open <- function(path){
    .Call(`_arrow_io___FileOutputStream__Open` , path)
}

io___BufferOutputStream__Create <- function(initial_capacity){
    .Call(`_arrow_io___BufferOutputStream__Create` , initial_capacity)
}

io___BufferOutputStream__capacity <- function(stream){
    .Call(`_arrow_io___BufferOutputStream__capacity` , stream)
}

io___BufferOutputStream__Finish <- function(stream){
    .Call(`_arrow_io___BufferOutputStream__Finish` , stream)
}

io___BufferOutputStream__Tell <- function(stream){
    .Call(`_arrow_io___BufferOutputStream__Tell` , stream)
}

io___BufferOutputStream__Write <- function(stream, bytes){
    invisible(.Call(`_arrow_io___BufferOutputStream__Write` , stream, bytes))
}

io___MockOutputStream__initialize <- function(){
    .Call(`_arrow_io___MockOutputStream__initialize` )
}

io___MockOutputStream__GetExtentBytesWritten <- function(stream){
    .Call(`_arrow_io___MockOutputStream__GetExtentBytesWritten` , stream)
}

io___FixedSizeBufferWriter__initialize <- function(buffer){
    .Call(`_arrow_io___FixedSizeBufferWriter__initialize` , buffer)
}

json___ReadOptions__initialize <- function(options){
    .Call(`_arrow_json___ReadOptions__initialize` , options)
}

json___ParseOptions__initialize <- function(options){
    .Call(`_arrow_json___ParseOptions__initialize` , options)
}

json___TableReader__Make <- function(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)
}

MemoryPool__default <- function(){
    .Call(`_arrow_MemoryPool__default` )
}

MemoryPool__bytes_allocated <- function(pool){
    .Call(`_arrow_MemoryPool__bytes_allocated` , pool)
}

MemoryPool__max_memory <- function(pool){
    .Call(`_arrow_MemoryPool__max_memory` , pool)
}

ipc___Message__body_length <- function(message){
    .Call(`_arrow_ipc___Message__body_length` , message)
}

ipc___Message__metadata <- function(message){
    .Call(`_arrow_ipc___Message__metadata` , message)
}

ipc___Message__body <- function(message){
    .Call(`_arrow_ipc___Message__body` , message)
}

ipc___Message__Verify <- function(message){
    .Call(`_arrow_ipc___Message__Verify` , message)
}

ipc___Message__type <- function(message){
    .Call(`_arrow_ipc___Message__type` , message)
}

ipc___Message__Equals <- function(x, y){
    .Call(`_arrow_ipc___Message__Equals` , x, y)
}

ipc___ReadRecordBatch__Message__Schema <- function(message, schema){
    .Call(`_arrow_ipc___ReadRecordBatch__Message__Schema` , message, schema)
}

ipc___ReadSchema_InputStream <- function(stream){
    .Call(`_arrow_ipc___ReadSchema_InputStream` , stream)
}

ipc___ReadSchema_Message <- function(message){
    .Call(`_arrow_ipc___ReadSchema_Message` , message)
}

ipc___MessageReader__Open <- function(stream){
    .Call(`_arrow_ipc___MessageReader__Open` , stream)
}

ipc___MessageReader__ReadNextMessage <- function(reader){
    .Call(`_arrow_ipc___MessageReader__ReadNextMessage` , reader)
}

ipc___ReadMessage <- function(stream){
    .Call(`_arrow_ipc___ReadMessage` , stream)
}

parquet___arrow___ArrowReaderProperties__Make <- function(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))
}

parquet___arrow___ArrowReaderProperties__get_use_threads <- function(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)
}

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))
}

parquet___arrow___FileReader__OpenFile <- function(file, props){
    .Call(`_arrow_parquet___arrow___FileReader__OpenFile` , file, props)
}

parquet___arrow___FileReader__ReadTable1 <- function(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)
}

write_parquet_file <- function(table, filename){
    invisible(.Call(`_arrow_write_parquet_file` , table, filename))
}

parquet___arrow___FileReader__GetSchema2 <- function(reader, indices){
    .Call(`_arrow_parquet___arrow___FileReader__GetSchema2` , reader, indices)
}

parquet___arrow___FileReader__GetSchema1 <- function(reader){
    .Call(`_arrow_parquet___arrow___FileReader__GetSchema1` , reader)
}

RecordBatch__num_columns <- function(x){
    .Call(`_arrow_RecordBatch__num_columns` , x)
}

RecordBatch__num_rows <- function(x){
    .Call(`_arrow_RecordBatch__num_rows` , x)
}

RecordBatch__schema <- function(x){
    .Call(`_arrow_RecordBatch__schema` , x)
}

RecordBatch__columns <- function(batch){
    .Call(`_arrow_RecordBatch__columns` , batch)
}

RecordBatch__column <- function(batch, i){
    .Call(`_arrow_RecordBatch__column` , batch, i)
}

RecordBatch__from_dataframe <- function(tbl){
    .Call(`_arrow_RecordBatch__from_dataframe` , tbl)
}

RecordBatch__Equals <- function(self, other){
    .Call(`_arrow_RecordBatch__Equals` , self, other)
}

RecordBatch__RemoveColumn <- function(batch, i){
    .Call(`_arrow_RecordBatch__RemoveColumn` , batch, i)
}

RecordBatch__column_name <- function(batch, i){
    .Call(`_arrow_RecordBatch__column_name` , batch, i)
}

RecordBatch__names <- function(batch){
    .Call(`_arrow_RecordBatch__names` , batch)
}

RecordBatch__Slice1 <- function(self, offset){
    .Call(`_arrow_RecordBatch__Slice1` , self, offset)
}

RecordBatch__Slice2 <- function(self, offset, length){
    .Call(`_arrow_RecordBatch__Slice2` , self, offset, length)
}

ipc___SerializeRecordBatch__Raw <- function(batch){
    .Call(`_arrow_ipc___SerializeRecordBatch__Raw` , batch)
}

ipc___ReadRecordBatch__InputStream__Schema <- function(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)
}

RecordBatchReader__schema <- function(reader){
    .Call(`_arrow_RecordBatchReader__schema` , reader)
}

RecordBatchReader__ReadNext <- function(reader){
    .Call(`_arrow_RecordBatchReader__ReadNext` , reader)
}

ipc___RecordBatchStreamReader__Open <- function(stream){
    .Call(`_arrow_ipc___RecordBatchStreamReader__Open` , stream)
}

ipc___RecordBatchStreamReader__batches <- function(reader){
    .Call(`_arrow_ipc___RecordBatchStreamReader__batches` , reader)
}

ipc___RecordBatchFileReader__schema <- function(reader){
    .Call(`_arrow_ipc___RecordBatchFileReader__schema` , reader)
}

ipc___RecordBatchFileReader__num_record_batches <- function(reader){
    .Call(`_arrow_ipc___RecordBatchFileReader__num_record_batches` , reader)
}

ipc___RecordBatchFileReader__ReadRecordBatch <- function(reader, i){
    .Call(`_arrow_ipc___RecordBatchFileReader__ReadRecordBatch` , reader, i)
}

ipc___RecordBatchFileReader__Open <- function(file){
    .Call(`_arrow_ipc___RecordBatchFileReader__Open` , file)
}

Table__from_RecordBatchFileReader <- function(reader){
    .Call(`_arrow_Table__from_RecordBatchFileReader` , reader)
}

Table__from_RecordBatchStreamReader <- function(reader){
    .Call(`_arrow_Table__from_RecordBatchStreamReader` , reader)
}

ipc___RecordBatchFileReader__batches <- function(reader){
    .Call(`_arrow_ipc___RecordBatchFileReader__batches` , reader)
}

ipc___RecordBatchWriter__WriteRecordBatch <- function(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))
}

ipc___RecordBatchWriter__Close <- function(batch_writer){
    invisible(.Call(`_arrow_ipc___RecordBatchWriter__Close` , batch_writer))
}

ipc___RecordBatchFileWriter__Open <- function(stream, schema){
    .Call(`_arrow_ipc___RecordBatchFileWriter__Open` , stream, schema)
}

ipc___RecordBatchStreamWriter__Open <- function(stream, schema){
    .Call(`_arrow_ipc___RecordBatchStreamWriter__Open` , stream, schema)
}

schema_ <- function(fields){
    .Call(`_arrow_schema_` , fields)
}

Schema__ToString <- function(s){
    .Call(`_arrow_Schema__ToString` , s)
}

Schema__num_fields <- function(s){
    .Call(`_arrow_Schema__num_fields` , s)
}

Schema__field <- function(s, i){
    .Call(`_arrow_Schema__field` , s, i)
}

Schema__names <- function(schema){
    .Call(`_arrow_Schema__names` , schema)
}

Schema__serialize <- function(schema){
    .Call(`_arrow_Schema__serialize` , schema)
}

Schema__Equals <- function(schema, other, check_metadata){
    .Call(`_arrow_Schema__Equals` , schema, other, check_metadata)
}

Table__from_dataframe <- function(tbl){
    .Call(`_arrow_Table__from_dataframe` , tbl)
}

Table__num_columns <- function(x){
    .Call(`_arrow_Table__num_columns` , x)
}

Table__num_rows <- function(x){
    .Call(`_arrow_Table__num_rows` , x)
}

Table__schema <- function(x){
    .Call(`_arrow_Table__schema` , x)
}

Table__column <- function(table, i){
    .Call(`_arrow_Table__column` , table, i)
}

Table__columns <- function(table){
    .Call(`_arrow_Table__columns` , table)
}

Table__column_names <- function(table){
    .Call(`_arrow_Table__column_names` , table)
}

Table__select <- function(table, indices){
    .Call(`_arrow_Table__select` , table, indices)
}

Table__from_dots <- function(lst, schema_sxp){
    .Call(`_arrow_Table__from_dots` , lst, schema_sxp)
}

GetCpuThreadPoolCapacity <- function(){
    .Call(`_arrow_GetCpuThreadPoolCapacity` )
}

SetCpuThreadPoolCapacity <- function(threads){
    invisible(.Call(`_arrow_SetCpuThreadPoolCapacity` , threads))
}