| # Generated by using data-raw/codegen.R -> do not edit by hand |
| |
| is_arrow_altrep <- function(x) { |
| .Call(`_arrow_is_arrow_altrep`, x) |
| } |
| |
| test_arrow_altrep_set_string_elt <- function(x, i, value) { |
| invisible(.Call(`_arrow_test_arrow_altrep_set_string_elt`, x, i, value)) |
| } |
| |
| test_arrow_altrep_is_materialized <- function(x) { |
| .Call(`_arrow_test_arrow_altrep_is_materialized`, x) |
| } |
| |
| test_arrow_altrep_force_materialize <- function(x) { |
| .Call(`_arrow_test_arrow_altrep_force_materialize`, x) |
| } |
| |
| test_arrow_altrep_copy_by_element <- function(x) { |
| .Call(`_arrow_test_arrow_altrep_copy_by_element`, x) |
| } |
| |
| test_arrow_altrep_copy_by_region <- function(x, region_size) { |
| .Call(`_arrow_test_arrow_altrep_copy_by_region`, x, region_size) |
| } |
| |
| test_arrow_altrep_copy_by_dataptr <- function(x) { |
| .Call(`_arrow_test_arrow_altrep_copy_by_dataptr`, x) |
| } |
| |
| 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__Diff <- function(lhs, rhs) { |
| .Call(`_arrow_Array__Diff`, 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__View <- function(array, type) { |
| .Call(`_arrow_Array__View`, array, type) |
| } |
| |
| Array__Validate <- function(array) { |
| invisible(.Call(`_arrow_Array__Validate`, 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__from_RecordBatch <- function(batch) { |
| .Call(`_arrow_StructArray__from_RecordBatch`, batch) |
| } |
| |
| StructArray__Flatten <- function(array) { |
| .Call(`_arrow_StructArray__Flatten`, array) |
| } |
| |
| ListArray__value_type <- function(array) { |
| .Call(`_arrow_ListArray__value_type`, array) |
| } |
| |
| LargeListArray__value_type <- function(array) { |
| .Call(`_arrow_LargeListArray__value_type`, array) |
| } |
| |
| ListArray__values <- function(array) { |
| .Call(`_arrow_ListArray__values`, array) |
| } |
| |
| LargeListArray__values <- function(array) { |
| .Call(`_arrow_LargeListArray__values`, array) |
| } |
| |
| ListArray__value_length <- function(array, i) { |
| .Call(`_arrow_ListArray__value_length`, array, i) |
| } |
| |
| LargeListArray__value_length <- function(array, i) { |
| .Call(`_arrow_LargeListArray__value_length`, array, i) |
| } |
| |
| FixedSizeListArray__value_length <- function(array, i) { |
| .Call(`_arrow_FixedSizeListArray__value_length`, array, i) |
| } |
| |
| ListArray__value_offset <- function(array, i) { |
| .Call(`_arrow_ListArray__value_offset`, array, i) |
| } |
| |
| LargeListArray__value_offset <- function(array, i) { |
| .Call(`_arrow_LargeListArray__value_offset`, array, i) |
| } |
| |
| FixedSizeListArray__value_offset <- function(array, i) { |
| .Call(`_arrow_FixedSizeListArray__value_offset`, array, i) |
| } |
| |
| ListArray__raw_value_offsets <- function(array) { |
| .Call(`_arrow_ListArray__raw_value_offsets`, array) |
| } |
| |
| LargeListArray__raw_value_offsets <- function(array) { |
| .Call(`_arrow_LargeListArray__raw_value_offsets`, array) |
| } |
| |
| MapArray__keys <- function(array) { |
| .Call(`_arrow_MapArray__keys`, array) |
| } |
| |
| MapArray__items <- function(array) { |
| .Call(`_arrow_MapArray__items`, array) |
| } |
| |
| MapArray__keys_nested <- function(array) { |
| .Call(`_arrow_MapArray__keys_nested`, array) |
| } |
| |
| MapArray__items_nested <- function(array) { |
| .Call(`_arrow_MapArray__items_nested`, array) |
| } |
| |
| Array__Same <- function(x, y) { |
| .Call(`_arrow_Array__Same`, x, y) |
| } |
| |
| Array__ReferencedBufferSize <- function(x) { |
| .Call(`_arrow_Array__ReferencedBufferSize`, x) |
| } |
| |
| arrow__Concatenate <- function(dots) { |
| .Call(`_arrow_arrow__Concatenate`, dots) |
| } |
| |
| Array__as_vector <- function(array) { |
| .Call(`_arrow_Array__as_vector`, array) |
| } |
| |
| ChunkedArray__as_vector <- function(chunked_array, use_threads) { |
| .Call(`_arrow_ChunkedArray__as_vector`, chunked_array, use_threads) |
| } |
| |
| 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) |
| } |
| |
| 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) |
| } |
| |
| external_pointer_addr_double <- function(external_pointer) { |
| .Call(`_arrow_external_pointer_addr_double`, external_pointer) |
| } |
| |
| external_pointer_addr_character <- function(external_pointer) { |
| .Call(`_arrow_external_pointer_addr_character`, external_pointer) |
| } |
| |
| external_pointer_addr_integer64 <- function(external_pointer) { |
| .Call(`_arrow_external_pointer_addr_integer64`, external_pointer) |
| } |
| |
| external_pointer_addr_raw <- function(external_pointer) { |
| .Call(`_arrow_external_pointer_addr_raw`, external_pointer) |
| } |
| |
| allocate_arrow_schema <- function() { |
| .Call(`_arrow_allocate_arrow_schema`) |
| } |
| |
| delete_arrow_schema <- function(ptr) { |
| invisible(.Call(`_arrow_delete_arrow_schema`, ptr)) |
| } |
| |
| allocate_arrow_array <- function() { |
| .Call(`_arrow_allocate_arrow_array`) |
| } |
| |
| delete_arrow_array <- function(ptr) { |
| invisible(.Call(`_arrow_delete_arrow_array`, ptr)) |
| } |
| |
| allocate_arrow_array_stream <- function() { |
| .Call(`_arrow_allocate_arrow_array_stream`) |
| } |
| |
| delete_arrow_array_stream <- function(ptr) { |
| invisible(.Call(`_arrow_delete_arrow_array_stream`, ptr)) |
| } |
| |
| ImportArray <- function(array, schema) { |
| .Call(`_arrow_ImportArray`, array, schema) |
| } |
| |
| ImportRecordBatch <- function(array, schema) { |
| .Call(`_arrow_ImportRecordBatch`, array, schema) |
| } |
| |
| ImportSchema <- function(schema) { |
| .Call(`_arrow_ImportSchema`, schema) |
| } |
| |
| ImportField <- function(field) { |
| .Call(`_arrow_ImportField`, field) |
| } |
| |
| ImportType <- function(type) { |
| .Call(`_arrow_ImportType`, type) |
| } |
| |
| ImportRecordBatchReader <- function(stream) { |
| .Call(`_arrow_ImportRecordBatchReader`, stream) |
| } |
| |
| ExportType <- function(type, ptr) { |
| invisible(.Call(`_arrow_ExportType`, type, ptr)) |
| } |
| |
| ExportField <- function(field, ptr) { |
| invisible(.Call(`_arrow_ExportField`, field, ptr)) |
| } |
| |
| ExportSchema <- function(schema, ptr) { |
| invisible(.Call(`_arrow_ExportSchema`, schema, ptr)) |
| } |
| |
| ExportArray <- function(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)) |
| } |
| |
| ExportRecordBatchReader <- function(reader, stream_ptr) { |
| invisible(.Call(`_arrow_ExportRecordBatchReader`, reader, stream_ptr)) |
| } |
| |
| 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) |
| } |
| |
| Buffer__Equals <- function(x, y) { |
| .Call(`_arrow_Buffer__Equals`, x, y) |
| } |
| |
| 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) |
| } |
| |
| ChunkedArray__Slice1 <- function(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) |
| } |
| |
| ChunkedArray__View <- function(array, type) { |
| .Call(`_arrow_ChunkedArray__View`, array, type) |
| } |
| |
| ChunkedArray__Validate <- function(chunked_array) { |
| invisible(.Call(`_arrow_ChunkedArray__Validate`, chunked_array)) |
| } |
| |
| ChunkedArray__Equals <- function(x, y) { |
| .Call(`_arrow_ChunkedArray__Equals`, x, y) |
| } |
| |
| ChunkedArray__ToString <- function(x) { |
| .Call(`_arrow_ChunkedArray__ToString`, x) |
| } |
| |
| ChunkedArray__from_list <- function(chunks, s_type) { |
| .Call(`_arrow_ChunkedArray__from_list`, chunks, s_type) |
| } |
| |
| ChunkedArray__ReferencedBufferSize <- function(chunked_array) { |
| .Call(`_arrow_ChunkedArray__ReferencedBufferSize`, chunked_array) |
| } |
| |
| util___Codec__Create <- function(codec, compression_level) { |
| .Call(`_arrow_util___Codec__Create`, codec, compression_level) |
| } |
| |
| util___Codec__name <- function(codec) { |
| .Call(`_arrow_util___Codec__name`, codec) |
| } |
| |
| util___Codec__IsAvailable <- function(codec) { |
| .Call(`_arrow_util___Codec__IsAvailable`, 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) |
| } |
| |
| ExecPlan_create <- function(use_threads) { |
| .Call(`_arrow_ExecPlan_create`, use_threads) |
| } |
| |
| ExecPlanReader__batches <- function(reader) { |
| .Call(`_arrow_ExecPlanReader__batches`, reader) |
| } |
| |
| Table__from_ExecPlanReader <- function(reader) { |
| .Call(`_arrow_Table__from_ExecPlanReader`, reader) |
| } |
| |
| ExecPlanReader__Plan <- function(reader) { |
| .Call(`_arrow_ExecPlanReader__Plan`, reader) |
| } |
| |
| ExecPlanReader__PlanStatus <- function(reader) { |
| .Call(`_arrow_ExecPlanReader__PlanStatus`, reader) |
| } |
| |
| ExecPlan_run <- function(plan, final_node, metadata) { |
| .Call(`_arrow_ExecPlan_run`, plan, final_node, metadata) |
| } |
| |
| ExecPlan_ToString <- function(plan) { |
| .Call(`_arrow_ExecPlan_ToString`, plan) |
| } |
| |
| ExecPlan_UnsafeDelete <- function(plan) { |
| invisible(.Call(`_arrow_ExecPlan_UnsafeDelete`, plan)) |
| } |
| |
| ExecNode_output_schema <- function(node) { |
| .Call(`_arrow_ExecNode_output_schema`, node) |
| } |
| |
| ExecNode_has_ordered_batches <- function(node) { |
| .Call(`_arrow_ExecNode_has_ordered_batches`, node) |
| } |
| |
| ExecNode_Scan <- function(plan, dataset, filter, projection) { |
| .Call(`_arrow_ExecNode_Scan`, plan, dataset, filter, projection) |
| } |
| |
| ExecPlan_Write <- function(plan, final_node, schema, file_write_options, filesystem, base_dir, partitioning, basename_template, existing_data_behavior, max_partitions, max_open_files, max_rows_per_file, min_rows_per_group, max_rows_per_group) { |
| invisible(.Call(`_arrow_ExecPlan_Write`, plan, final_node, schema, file_write_options, filesystem, base_dir, partitioning, basename_template, existing_data_behavior, max_partitions, max_open_files, max_rows_per_file, min_rows_per_group, max_rows_per_group)) |
| } |
| |
| ExecNode_Filter <- function(input, filter) { |
| .Call(`_arrow_ExecNode_Filter`, input, filter) |
| } |
| |
| ExecNode_Project <- function(input, exprs, names) { |
| .Call(`_arrow_ExecNode_Project`, input, exprs, names) |
| } |
| |
| ExecNode_Aggregate <- function(input, options, key_names) { |
| .Call(`_arrow_ExecNode_Aggregate`, input, options, key_names) |
| } |
| |
| ExecNode_Join <- function(input, join_type, right_data, left_keys, right_keys, left_output, right_output, output_suffix_for_left, output_suffix_for_right, na_matches) { |
| .Call(`_arrow_ExecNode_Join`, input, join_type, right_data, left_keys, right_keys, left_output, right_output, output_suffix_for_left, output_suffix_for_right, na_matches) |
| } |
| |
| ExecNode_Union <- function(input, right_data) { |
| .Call(`_arrow_ExecNode_Union`, input, right_data) |
| } |
| |
| ExecNode_Fetch <- function(input, offset, limit) { |
| .Call(`_arrow_ExecNode_Fetch`, input, offset, limit) |
| } |
| |
| ExecNode_OrderBy <- function(input, sort_options) { |
| .Call(`_arrow_ExecNode_OrderBy`, input, sort_options) |
| } |
| |
| ExecNode_SourceNode <- function(plan, reader) { |
| .Call(`_arrow_ExecNode_SourceNode`, plan, reader) |
| } |
| |
| ExecNode_TableSourceNode <- function(plan, table) { |
| .Call(`_arrow_ExecNode_TableSourceNode`, plan, table) |
| } |
| |
| substrait__internal__SubstraitToJSON <- function(serialized_plan) { |
| .Call(`_arrow_substrait__internal__SubstraitToJSON`, serialized_plan) |
| } |
| |
| substrait__internal__SubstraitFromJSON <- function(substrait_json) { |
| .Call(`_arrow_substrait__internal__SubstraitFromJSON`, substrait_json) |
| } |
| |
| ExecPlan_run_substrait <- function(plan, serialized_plan) { |
| .Call(`_arrow_ExecPlan_run_substrait`, plan, serialized_plan) |
| } |
| |
| 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) |
| } |
| |
| compute__CallFunction <- function(func_name, args, options) { |
| .Call(`_arrow_compute__CallFunction`, func_name, args, options) |
| } |
| |
| compute__GetFunctionNames <- function() { |
| .Call(`_arrow_compute__GetFunctionNames`) |
| } |
| |
| RegisterScalarUDF <- function(name, func_sexp) { |
| invisible(.Call(`_arrow_RegisterScalarUDF`, name, func_sexp)) |
| } |
| |
| build_info <- function() { |
| .Call(`_arrow_build_info`) |
| } |
| |
| runtime_info <- function() { |
| .Call(`_arrow_runtime_info`) |
| } |
| |
| set_timezone_database <- function(path) { |
| invisible(.Call(`_arrow_set_timezone_database`, path)) |
| } |
| |
| csv___WriteOptions__initialize <- function(options) { |
| .Call(`_arrow_csv___WriteOptions__initialize`, options) |
| } |
| |
| csv___ReadOptions__initialize <- function(options) { |
| .Call(`_arrow_csv___ReadOptions__initialize`, options) |
| } |
| |
| csv___ParseOptions__initialize <- function(options) { |
| .Call(`_arrow_csv___ParseOptions__initialize`, options) |
| } |
| |
| csv___ReadOptions__column_names <- function(options) { |
| .Call(`_arrow_csv___ReadOptions__column_names`, options) |
| } |
| |
| csv___ReadOptions__block_size <- function(options) { |
| .Call(`_arrow_csv___ReadOptions__block_size`, options) |
| } |
| |
| csv___ReadOptions__skip_rows <- function(options) { |
| .Call(`_arrow_csv___ReadOptions__skip_rows`, options) |
| } |
| |
| csv___ReadOptions__autogenerate_column_names <- function(options) { |
| .Call(`_arrow_csv___ReadOptions__autogenerate_column_names`, options) |
| } |
| |
| csv___ReadOptions__use_threads <- function(options) { |
| .Call(`_arrow_csv___ReadOptions__use_threads`, options) |
| } |
| |
| csv___ReadOptions__skip_rows_after_names <- function(options) { |
| .Call(`_arrow_csv___ReadOptions__skip_rows_after_names`, 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) |
| } |
| |
| TimestampParser__kind <- function(parser) { |
| .Call(`_arrow_TimestampParser__kind`, parser) |
| } |
| |
| TimestampParser__format <- function(parser) { |
| .Call(`_arrow_TimestampParser__format`, parser) |
| } |
| |
| TimestampParser__MakeStrptime <- function(format) { |
| .Call(`_arrow_TimestampParser__MakeStrptime`, format) |
| } |
| |
| TimestampParser__MakeISO8601 <- function() { |
| .Call(`_arrow_TimestampParser__MakeISO8601`) |
| } |
| |
| csv___WriteCSV__Table <- function(table, write_options, stream) { |
| invisible(.Call(`_arrow_csv___WriteCSV__Table`, table, write_options, stream)) |
| } |
| |
| csv___WriteCSV__RecordBatch <- function(record_batch, write_options, stream) { |
| invisible(.Call(`_arrow_csv___WriteCSV__RecordBatch`, record_batch, write_options, stream)) |
| } |
| |
| csv___WriteCSV__RecordBatchReader <- function(reader, write_options, stream) { |
| invisible(.Call(`_arrow_csv___WriteCSV__RecordBatchReader`, reader, write_options, stream)) |
| } |
| |
| dataset___Dataset__NewScan <- function(ds) { |
| .Call(`_arrow_dataset___Dataset__NewScan`, ds) |
| } |
| |
| dataset___Dataset__schema <- function(dataset) { |
| .Call(`_arrow_dataset___Dataset__schema`, dataset) |
| } |
| |
| dataset___Dataset__type_name <- function(dataset) { |
| .Call(`_arrow_dataset___Dataset__type_name`, dataset) |
| } |
| |
| dataset___Dataset__ReplaceSchema <- function(dataset, schm) { |
| .Call(`_arrow_dataset___Dataset__ReplaceSchema`, dataset, schm) |
| } |
| |
| dataset___UnionDataset__create <- function(datasets, schm) { |
| .Call(`_arrow_dataset___UnionDataset__create`, datasets, schm) |
| } |
| |
| dataset___InMemoryDataset__create <- function(table) { |
| .Call(`_arrow_dataset___InMemoryDataset__create`, table) |
| } |
| |
| dataset___UnionDataset__children <- function(ds) { |
| .Call(`_arrow_dataset___UnionDataset__children`, ds) |
| } |
| |
| dataset___FileSystemDataset__format <- function(dataset) { |
| .Call(`_arrow_dataset___FileSystemDataset__format`, dataset) |
| } |
| |
| dataset___FileSystemDataset__filesystem <- function(dataset) { |
| .Call(`_arrow_dataset___FileSystemDataset__filesystem`, dataset) |
| } |
| |
| dataset___FileSystemDataset__files <- function(dataset) { |
| .Call(`_arrow_dataset___FileSystemDataset__files`, dataset) |
| } |
| |
| dataset___DatasetFactory__Finish1 <- function(factory, unify_schemas) { |
| .Call(`_arrow_dataset___DatasetFactory__Finish1`, factory, unify_schemas) |
| } |
| |
| dataset___DatasetFactory__Finish2 <- function(factory, schema) { |
| .Call(`_arrow_dataset___DatasetFactory__Finish2`, factory, schema) |
| } |
| |
| dataset___DatasetFactory__Inspect <- function(factory, unify_schemas) { |
| .Call(`_arrow_dataset___DatasetFactory__Inspect`, factory, unify_schemas) |
| } |
| |
| dataset___UnionDatasetFactory__Make <- function(children) { |
| .Call(`_arrow_dataset___UnionDatasetFactory__Make`, children) |
| } |
| |
| dataset___FileSystemDatasetFactory__Make <- function(fs, selector, format, fsf_options) { |
| .Call(`_arrow_dataset___FileSystemDatasetFactory__Make`, fs, selector, format, fsf_options) |
| } |
| |
| dataset___FileSystemDatasetFactory__MakePaths <- function(fs, paths, format, exclude_invalid_files) { |
| .Call(`_arrow_dataset___FileSystemDatasetFactory__MakePaths`, fs, paths, format, exclude_invalid_files) |
| } |
| |
| dataset___FileFormat__type_name <- function(format) { |
| .Call(`_arrow_dataset___FileFormat__type_name`, format) |
| } |
| |
| dataset___FileFormat__DefaultWriteOptions <- function(fmt) { |
| .Call(`_arrow_dataset___FileFormat__DefaultWriteOptions`, fmt) |
| } |
| |
| dataset___ParquetFileFormat__Make <- function(options, dict_columns) { |
| .Call(`_arrow_dataset___ParquetFileFormat__Make`, options, dict_columns) |
| } |
| |
| dataset___FileWriteOptions__type_name <- function(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)) |
| } |
| |
| 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)) |
| } |
| |
| dataset___IpcFileWriteOptions__update1 <- function(ipc_options, use_legacy_format, metadata_version) { |
| invisible(.Call(`_arrow_dataset___IpcFileWriteOptions__update1`, ipc_options, use_legacy_format, metadata_version)) |
| } |
| |
| dataset___CsvFileWriteOptions__update <- function(csv_options, write_options) { |
| invisible(.Call(`_arrow_dataset___CsvFileWriteOptions__update`, csv_options, write_options)) |
| } |
| |
| dataset___IpcFileFormat__Make <- function() { |
| .Call(`_arrow_dataset___IpcFileFormat__Make`) |
| } |
| |
| dataset___CsvFileFormat__Make <- function(parse_options, convert_options, read_options) { |
| .Call(`_arrow_dataset___CsvFileFormat__Make`, parse_options, convert_options, read_options) |
| } |
| |
| dataset___JsonFileFormat__Make <- function(parse_options, read_options) { |
| .Call(`_arrow_dataset___JsonFileFormat__Make`, parse_options, read_options) |
| } |
| |
| dataset___FragmentScanOptions__type_name <- function(fragment_scan_options) { |
| .Call(`_arrow_dataset___FragmentScanOptions__type_name`, fragment_scan_options) |
| } |
| |
| dataset___CsvFragmentScanOptions__Make <- function(convert_options, read_options) { |
| .Call(`_arrow_dataset___CsvFragmentScanOptions__Make`, convert_options, read_options) |
| } |
| |
| dataset___JsonFragmentScanOptions__Make <- function(parse_options, read_options) { |
| .Call(`_arrow_dataset___JsonFragmentScanOptions__Make`, parse_options, read_options) |
| } |
| |
| dataset___ParquetFragmentScanOptions__Make <- function(use_buffered_stream, buffer_size, pre_buffer, thrift_string_size_limit, thrift_container_size_limit) { |
| .Call(`_arrow_dataset___ParquetFragmentScanOptions__Make`, use_buffered_stream, buffer_size, pre_buffer, thrift_string_size_limit, thrift_container_size_limit) |
| } |
| |
| dataset___DirectoryPartitioning <- function(schm, segment_encoding) { |
| .Call(`_arrow_dataset___DirectoryPartitioning`, schm, segment_encoding) |
| } |
| |
| dataset___DirectoryPartitioning__MakeFactory <- function(field_names, segment_encoding) { |
| .Call(`_arrow_dataset___DirectoryPartitioning__MakeFactory`, field_names, segment_encoding) |
| } |
| |
| dataset___HivePartitioning <- function(schm, null_fallback, segment_encoding) { |
| .Call(`_arrow_dataset___HivePartitioning`, schm, null_fallback, segment_encoding) |
| } |
| |
| dataset___HivePartitioning__MakeFactory <- function(null_fallback, segment_encoding) { |
| .Call(`_arrow_dataset___HivePartitioning__MakeFactory`, null_fallback, segment_encoding) |
| } |
| |
| dataset___PartitioningFactory__Inspect <- function(factory, paths) { |
| .Call(`_arrow_dataset___PartitioningFactory__Inspect`, factory, paths) |
| } |
| |
| dataset___PartitioningFactory__Finish <- function(factory, schema) { |
| .Call(`_arrow_dataset___PartitioningFactory__Finish`, factory, schema) |
| } |
| |
| dataset___PartitioningFactory__type_name <- function(factory) { |
| .Call(`_arrow_dataset___PartitioningFactory__type_name`, factory) |
| } |
| |
| dataset___ScannerBuilder__ProjectNames <- function(sb, cols) { |
| invisible(.Call(`_arrow_dataset___ScannerBuilder__ProjectNames`, sb, cols)) |
| } |
| |
| dataset___ScannerBuilder__ProjectExprs <- function(sb, exprs, names) { |
| invisible(.Call(`_arrow_dataset___ScannerBuilder__ProjectExprs`, sb, exprs, names)) |
| } |
| |
| dataset___ScannerBuilder__Filter <- function(sb, expr) { |
| invisible(.Call(`_arrow_dataset___ScannerBuilder__Filter`, sb, expr)) |
| } |
| |
| dataset___ScannerBuilder__UseThreads <- function(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)) |
| } |
| |
| dataset___ScannerBuilder__FragmentScanOptions <- function(sb, options) { |
| invisible(.Call(`_arrow_dataset___ScannerBuilder__FragmentScanOptions`, sb, options)) |
| } |
| |
| dataset___ScannerBuilder__schema <- function(sb) { |
| .Call(`_arrow_dataset___ScannerBuilder__schema`, sb) |
| } |
| |
| dataset___ScannerBuilder__Finish <- function(sb) { |
| .Call(`_arrow_dataset___ScannerBuilder__Finish`, sb) |
| } |
| |
| dataset___ScannerBuilder__FromRecordBatchReader <- function(reader) { |
| .Call(`_arrow_dataset___ScannerBuilder__FromRecordBatchReader`, reader) |
| } |
| |
| dataset___Scanner__ToTable <- function(scanner) { |
| .Call(`_arrow_dataset___Scanner__ToTable`, scanner) |
| } |
| |
| dataset___Scanner__ScanBatches <- function(scanner) { |
| .Call(`_arrow_dataset___Scanner__ScanBatches`, scanner) |
| } |
| |
| dataset___Scanner__ToRecordBatchReader <- function(scanner) { |
| .Call(`_arrow_dataset___Scanner__ToRecordBatchReader`, scanner) |
| } |
| |
| dataset___Scanner__head <- function(scanner, n) { |
| .Call(`_arrow_dataset___Scanner__head`, scanner, n) |
| } |
| |
| dataset___Scanner__schema <- function(sc) { |
| .Call(`_arrow_dataset___Scanner__schema`, sc) |
| } |
| |
| dataset___Scanner__TakeRows <- function(scanner, indices) { |
| .Call(`_arrow_dataset___Scanner__TakeRows`, scanner, indices) |
| } |
| |
| dataset___Scanner__CountRows <- function(scanner) { |
| .Call(`_arrow_dataset___Scanner__CountRows`, scanner) |
| } |
| |
| 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`) |
| } |
| |
| LargeUtf8__initialize <- function() { |
| .Call(`_arrow_LargeUtf8__initialize`) |
| } |
| |
| Binary__initialize <- function() { |
| .Call(`_arrow_Binary__initialize`) |
| } |
| |
| LargeBinary__initialize <- function() { |
| .Call(`_arrow_LargeBinary__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) |
| } |
| |
| Decimal256Type__initialize <- function(precision, scale) { |
| .Call(`_arrow_Decimal256Type__initialize`, precision, scale) |
| } |
| |
| DayTimeInterval__initialize <- function() { |
| .Call(`_arrow_DayTimeInterval__initialize`) |
| } |
| |
| FixedSizeBinary__initialize <- function(byte_width) { |
| .Call(`_arrow_FixedSizeBinary__initialize`, byte_width) |
| } |
| |
| FixedSizeBinary__byte_width <- function(type) { |
| .Call(`_arrow_FixedSizeBinary__byte_width`, type) |
| } |
| |
| Timestamp__initialize <- function(unit, timezone) { |
| .Call(`_arrow_Timestamp__initialize`, unit, timezone) |
| } |
| |
| Time32__initialize <- function(unit) { |
| .Call(`_arrow_Time32__initialize`, unit) |
| } |
| |
| Time64__initialize <- function(unit) { |
| .Call(`_arrow_Time64__initialize`, unit) |
| } |
| |
| Duration__initialize <- function(unit) { |
| .Call(`_arrow_Duration__initialize`, unit) |
| } |
| |
| list__ <- function(x) { |
| .Call(`_arrow_list__`, x) |
| } |
| |
| large_list__ <- function(x) { |
| .Call(`_arrow_large_list__`, x) |
| } |
| |
| fixed_size_list__ <- function(x, list_size) { |
| .Call(`_arrow_fixed_size_list__`, x, list_size) |
| } |
| |
| map__ <- function(key, item, keys_sorted) { |
| .Call(`_arrow_map__`, key, item, keys_sorted) |
| } |
| |
| 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, check_metadata) { |
| .Call(`_arrow_DataType__Equals`, lhs, rhs, check_metadata) |
| } |
| |
| DataType__num_fields <- function(type) { |
| .Call(`_arrow_DataType__num_fields`, type) |
| } |
| |
| DataType__fields <- function(type) { |
| .Call(`_arrow_DataType__fields`, 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) |
| } |
| |
| DurationType__unit <- function(type) { |
| .Call(`_arrow_DurationType__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) |
| } |
| |
| StructType__field_names <- function(type) { |
| .Call(`_arrow_StructType__field_names`, type) |
| } |
| |
| ListType__value_field <- function(type) { |
| .Call(`_arrow_ListType__value_field`, type) |
| } |
| |
| ListType__value_type <- function(type) { |
| .Call(`_arrow_ListType__value_type`, type) |
| } |
| |
| LargeListType__value_field <- function(type) { |
| .Call(`_arrow_LargeListType__value_field`, type) |
| } |
| |
| LargeListType__value_type <- function(type) { |
| .Call(`_arrow_LargeListType__value_type`, type) |
| } |
| |
| FixedSizeListType__value_field <- function(type) { |
| .Call(`_arrow_FixedSizeListType__value_field`, type) |
| } |
| |
| FixedSizeListType__value_type <- function(type) { |
| .Call(`_arrow_FixedSizeListType__value_type`, type) |
| } |
| |
| FixedSizeListType__list_size <- function(type) { |
| .Call(`_arrow_FixedSizeListType__list_size`, type) |
| } |
| |
| MapType__key_field <- function(type) { |
| .Call(`_arrow_MapType__key_field`, type) |
| } |
| |
| MapType__item_field <- function(type) { |
| .Call(`_arrow_MapType__item_field`, type) |
| } |
| |
| MapType__key_type <- function(type) { |
| .Call(`_arrow_MapType__key_type`, type) |
| } |
| |
| MapType__item_type <- function(type) { |
| .Call(`_arrow_MapType__item_type`, type) |
| } |
| |
| MapType__keys_sorted <- function(type) { |
| .Call(`_arrow_MapType__keys_sorted`, type) |
| } |
| |
| compute___expr__equals <- function(lhs, rhs) { |
| .Call(`_arrow_compute___expr__equals`, lhs, rhs) |
| } |
| |
| compute___expr__call <- function(func_name, argument_list, options) { |
| .Call(`_arrow_compute___expr__call`, func_name, argument_list, options) |
| } |
| |
| compute___expr__is_field_ref <- function(x) { |
| .Call(`_arrow_compute___expr__is_field_ref`, x) |
| } |
| |
| compute___expr__get_field_ref_name <- function(x) { |
| .Call(`_arrow_compute___expr__get_field_ref_name`, x) |
| } |
| |
| compute___expr__field_names_in_expression <- function(x) { |
| .Call(`_arrow_compute___expr__field_names_in_expression`, x) |
| } |
| |
| compute___expr__field_ref <- function(name) { |
| .Call(`_arrow_compute___expr__field_ref`, name) |
| } |
| |
| compute___expr__nested_field_ref <- function(x, name) { |
| .Call(`_arrow_compute___expr__nested_field_ref`, x, name) |
| } |
| |
| compute___expr__scalar <- function(x) { |
| .Call(`_arrow_compute___expr__scalar`, x) |
| } |
| |
| compute___expr__ToString <- function(x) { |
| .Call(`_arrow_compute___expr__ToString`, x) |
| } |
| |
| compute___expr__type <- function(x, schema) { |
| .Call(`_arrow_compute___expr__type`, x, schema) |
| } |
| |
| compute___expr__type_id <- function(x, schema) { |
| .Call(`_arrow_compute___expr__type_id`, x, schema) |
| } |
| |
| ExtensionType__initialize <- function(storage_type, extension_name, extension_metadata, r6_class) { |
| .Call(`_arrow_ExtensionType__initialize`, storage_type, extension_name, extension_metadata, r6_class) |
| } |
| |
| ExtensionType__extension_name <- function(type) { |
| .Call(`_arrow_ExtensionType__extension_name`, type) |
| } |
| |
| ExtensionType__Serialize <- function(type) { |
| .Call(`_arrow_ExtensionType__Serialize`, type) |
| } |
| |
| ExtensionType__storage_type <- function(type) { |
| .Call(`_arrow_ExtensionType__storage_type`, type) |
| } |
| |
| ExtensionType__MakeArray <- function(type, data) { |
| .Call(`_arrow_ExtensionType__MakeArray`, type, data) |
| } |
| |
| ExtensionType__r6_class <- function(type) { |
| .Call(`_arrow_ExtensionType__r6_class`, type) |
| } |
| |
| ExtensionArray__storage <- function(array) { |
| .Call(`_arrow_ExtensionArray__storage`, array) |
| } |
| |
| arrow__RegisterRExtensionType <- function(type) { |
| invisible(.Call(`_arrow_arrow__RegisterRExtensionType`, type)) |
| } |
| |
| arrow__UnregisterRExtensionType <- function(type_name) { |
| invisible(.Call(`_arrow_arrow__UnregisterRExtensionType`, type_name)) |
| } |
| |
| 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)) |
| } |
| |
| ipc___feather___Reader__version <- function(reader) { |
| .Call(`_arrow_ipc___feather___Reader__version`, reader) |
| } |
| |
| ipc___feather___Reader__Read <- function(reader, columns) { |
| .Call(`_arrow_ipc___feather___Reader__Read`, reader, columns) |
| } |
| |
| ipc___feather___Reader__Open <- function(stream) { |
| .Call(`_arrow_ipc___feather___Reader__Open`, stream) |
| } |
| |
| ipc___feather___Reader__schema <- function(reader) { |
| .Call(`_arrow_ipc___feather___Reader__schema`, 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) |
| } |
| |
| fs___FileInfo__type <- function(x) { |
| .Call(`_arrow_fs___FileInfo__type`, x) |
| } |
| |
| fs___FileInfo__set_type <- function(x, type) { |
| invisible(.Call(`_arrow_fs___FileInfo__set_type`, x, type)) |
| } |
| |
| fs___FileInfo__path <- function(x) { |
| .Call(`_arrow_fs___FileInfo__path`, x) |
| } |
| |
| fs___FileInfo__set_path <- function(x, path) { |
| invisible(.Call(`_arrow_fs___FileInfo__set_path`, x, path)) |
| } |
| |
| fs___FileInfo__size <- function(x) { |
| .Call(`_arrow_fs___FileInfo__size`, x) |
| } |
| |
| fs___FileInfo__set_size <- function(x, size) { |
| invisible(.Call(`_arrow_fs___FileInfo__set_size`, x, size)) |
| } |
| |
| fs___FileInfo__base_name <- function(x) { |
| .Call(`_arrow_fs___FileInfo__base_name`, x) |
| } |
| |
| fs___FileInfo__extension <- function(x) { |
| .Call(`_arrow_fs___FileInfo__extension`, x) |
| } |
| |
| fs___FileInfo__mtime <- function(x) { |
| .Call(`_arrow_fs___FileInfo__mtime`, x) |
| } |
| |
| fs___FileInfo__set_mtime <- function(x, time) { |
| invisible(.Call(`_arrow_fs___FileInfo__set_mtime`, x, time)) |
| } |
| |
| fs___FileSelector__base_dir <- function(selector) { |
| .Call(`_arrow_fs___FileSelector__base_dir`, selector) |
| } |
| |
| fs___FileSelector__allow_not_found <- function(selector) { |
| .Call(`_arrow_fs___FileSelector__allow_not_found`, selector) |
| } |
| |
| fs___FileSelector__recursive <- function(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) |
| } |
| |
| fs___FileSystem__GetTargetInfos_Paths <- function(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) |
| } |
| |
| fs___FileSystem__CreateDir <- function(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)) |
| } |
| |
| fs___FileSystem__DeleteDirContents <- function(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)) |
| } |
| |
| fs___FileSystem__DeleteFiles <- function(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)) |
| } |
| |
| fs___FileSystem__CopyFile <- function(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) |
| } |
| |
| fs___FileSystem__OpenInputFile <- function(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) |
| } |
| |
| fs___FileSystem__OpenAppendStream <- function(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) |
| } |
| |
| fs___SubTreeFileSystem__create <- function(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) |
| } |
| |
| fs___SubTreeFileSystem__base_path <- function(file_system) { |
| .Call(`_arrow_fs___SubTreeFileSystem__base_path`, file_system) |
| } |
| |
| fs___FileSystemFromUri <- function(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)) |
| } |
| |
| fs___S3FileSystem__create <- function(anonymous, access_key, secret_key, session_token, role_arn, session_name, external_id, load_frequency, region, endpoint_override, scheme, proxy_options, background_writes, allow_bucket_creation, allow_bucket_deletion, connect_timeout, request_timeout) { |
| .Call(`_arrow_fs___S3FileSystem__create`, anonymous, access_key, secret_key, session_token, role_arn, session_name, external_id, load_frequency, region, endpoint_override, scheme, proxy_options, background_writes, allow_bucket_creation, allow_bucket_deletion, connect_timeout, request_timeout) |
| } |
| |
| fs___S3FileSystem__region <- function(fs) { |
| .Call(`_arrow_fs___S3FileSystem__region`, fs) |
| } |
| |
| FinalizeS3 <- function() { |
| invisible(.Call(`_arrow_FinalizeS3`)) |
| } |
| |
| fs___GcsFileSystem__Make <- function(anonymous, options) { |
| .Call(`_arrow_fs___GcsFileSystem__Make`, anonymous, options) |
| } |
| |
| fs___GcsFileSystem__options <- function(fs) { |
| .Call(`_arrow_fs___GcsFileSystem__options`, fs) |
| } |
| |
| 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___RandomAccessFile__ReadMetadata <- function(x) { |
| .Call(`_arrow_io___RandomAccessFile__ReadMetadata`, x) |
| } |
| |
| 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)) |
| } |
| |
| MakeRConnectionInputStream <- function(con) { |
| .Call(`_arrow_MakeRConnectionInputStream`, con) |
| } |
| |
| MakeRConnectionOutputStream <- function(con) { |
| .Call(`_arrow_MakeRConnectionOutputStream`, con) |
| } |
| |
| MakeRConnectionRandomAccessFile <- function(con) { |
| .Call(`_arrow_MakeRConnectionRandomAccessFile`, con) |
| } |
| |
| MakeReencodeInputStream <- function(wrapped, from) { |
| .Call(`_arrow_MakeReencodeInputStream`, wrapped, from) |
| } |
| |
| json___ReadOptions__initialize <- function(use_threads, block_size) { |
| .Call(`_arrow_json___ReadOptions__initialize`, use_threads, block_size) |
| } |
| |
| json___ParseOptions__initialize1 <- function(newlines_in_values) { |
| .Call(`_arrow_json___ParseOptions__initialize1`, newlines_in_values) |
| } |
| |
| json___ParseOptions__initialize2 <- function(newlines_in_values, explicit_schema) { |
| .Call(`_arrow_json___ParseOptions__initialize2`, newlines_in_values, explicit_schema) |
| } |
| |
| 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) |
| } |
| |
| MemoryPool__backend_name <- function(pool) { |
| .Call(`_arrow_MemoryPool__backend_name`, pool) |
| } |
| |
| supported_memory_backends <- function() { |
| .Call(`_arrow_supported_memory_backends`) |
| } |
| |
| 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___ReaderProperties__Make <- function() { |
| .Call(`_arrow_parquet___arrow___ReaderProperties__Make`) |
| } |
| |
| parquet___arrow___ReaderProperties__get_thrift_string_size_limit <- function(properties) { |
| .Call(`_arrow_parquet___arrow___ReaderProperties__get_thrift_string_size_limit`, properties) |
| } |
| |
| parquet___arrow___ReaderProperties__set_thrift_string_size_limit <- function(properties, size) { |
| invisible(.Call(`_arrow_parquet___arrow___ReaderProperties__set_thrift_string_size_limit`, properties, size)) |
| } |
| |
| parquet___arrow___ReaderProperties__get_thrift_container_size_limit <- function(properties) { |
| .Call(`_arrow_parquet___arrow___ReaderProperties__get_thrift_container_size_limit`, properties) |
| } |
| |
| parquet___arrow___ReaderProperties__set_thrift_container_size_limit <- function(properties, size) { |
| invisible(.Call(`_arrow_parquet___arrow___ReaderProperties__set_thrift_container_size_limit`, properties, size)) |
| } |
| |
| 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___ArrowReaderProperties__set_coerce_int96_timestamp_unit <- function(properties, unit) { |
| invisible(.Call(`_arrow_parquet___arrow___ArrowReaderProperties__set_coerce_int96_timestamp_unit`, properties, unit)) |
| } |
| |
| parquet___arrow___ArrowReaderProperties__get_coerce_int96_timestamp_unit <- function(properties) { |
| .Call(`_arrow_parquet___arrow___ArrowReaderProperties__get_coerce_int96_timestamp_unit`, properties) |
| } |
| |
| parquet___arrow___FileReader__OpenFile <- function(file, props, reader_props) { |
| .Call(`_arrow_parquet___arrow___FileReader__OpenFile`, file, props, reader_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) |
| } |
| |
| parquet___arrow___FileReader__ReadRowGroup1 <- function(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) |
| } |
| |
| parquet___arrow___FileReader__ReadRowGroups1 <- function(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) |
| } |
| |
| parquet___arrow___FileReader__num_rows <- function(reader) { |
| .Call(`_arrow_parquet___arrow___FileReader__num_rows`, reader) |
| } |
| |
| parquet___arrow___FileReader__num_columns <- function(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) |
| } |
| |
| parquet___arrow___FileReader__ReadColumn <- function(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) |
| } |
| |
| parquet___WriterProperties___Builder__create <- function() { |
| .Call(`_arrow_parquet___WriterProperties___Builder__create`) |
| } |
| |
| parquet___WriterProperties___Builder__version <- function(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)) |
| } |
| |
| parquet___ArrowWriterProperties___Builder__set_compression_levels <- function(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)) |
| } |
| |
| parquet___ArrowWriterProperties___Builder__set_write_statistics <- function(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)) |
| } |
| |
| parquet___WriterProperties___Builder__build <- function(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) |
| } |
| |
| parquet___arrow___FileWriter__WriteTable <- function(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)) |
| } |
| |
| parquet___arrow___WriteTable <- function(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) |
| } |
| |
| Table__from_dots <- function(lst, schema_sxp, use_threads) { |
| .Call(`_arrow_Table__from_dots`, lst, schema_sxp, use_threads) |
| } |
| |
| vec_to_Array <- function(x, s_type) { |
| .Call(`_arrow_vec_to_Array`, x, s_type) |
| } |
| |
| DictionaryArray__FromArrays <- function(type, indices, dict) { |
| .Call(`_arrow_DictionaryArray__FromArrays`, type, indices, dict) |
| } |
| |
| 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__RenameColumns <- function(batch, names) { |
| .Call(`_arrow_RecordBatch__RenameColumns`, batch, names) |
| } |
| |
| RecordBatch__ReplaceSchemaMetadata <- function(x, metadata) { |
| .Call(`_arrow_RecordBatch__ReplaceSchemaMetadata`, x, metadata) |
| } |
| |
| RecordBatch__columns <- function(batch) { |
| .Call(`_arrow_RecordBatch__columns`, batch) |
| } |
| |
| RecordBatch__column <- function(batch, i) { |
| .Call(`_arrow_RecordBatch__column`, batch, i) |
| } |
| |
| RecordBatch__GetColumnByName <- function(batch, name) { |
| .Call(`_arrow_RecordBatch__GetColumnByName`, batch, name) |
| } |
| |
| RecordBatch__SelectColumns <- function(batch, indices) { |
| .Call(`_arrow_RecordBatch__SelectColumns`, batch, indices) |
| } |
| |
| RecordBatch__Equals <- function(self, other, check_metadata) { |
| .Call(`_arrow_RecordBatch__Equals`, self, other, check_metadata) |
| } |
| |
| RecordBatch__AddColumn <- function(batch, i, field, column) { |
| .Call(`_arrow_RecordBatch__AddColumn`, batch, i, field, column) |
| } |
| |
| RecordBatch__SetColumn <- function(batch, i, field, column) { |
| .Call(`_arrow_RecordBatch__SetColumn`, batch, i, field, column) |
| } |
| |
| 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) |
| } |
| |
| RecordBatch__ReferencedBufferSize <- function(batch) { |
| .Call(`_arrow_RecordBatch__ReferencedBufferSize`, batch) |
| } |
| |
| RecordBatchReader__schema <- function(reader) { |
| .Call(`_arrow_RecordBatchReader__schema`, reader) |
| } |
| |
| RecordBatchReader__Close <- function(reader) { |
| invisible(.Call(`_arrow_RecordBatchReader__Close`, reader)) |
| } |
| |
| RecordBatchReader__UnsafeDelete <- function(reader) { |
| invisible(.Call(`_arrow_RecordBatchReader__UnsafeDelete`, reader)) |
| } |
| |
| RecordBatchReader__ReadNext <- function(reader) { |
| .Call(`_arrow_RecordBatchReader__ReadNext`, reader) |
| } |
| |
| RecordBatchReader__batches <- function(reader) { |
| .Call(`_arrow_RecordBatchReader__batches`, reader) |
| } |
| |
| RecordBatchReader__from_batches <- function(batches, schema_sxp) { |
| .Call(`_arrow_RecordBatchReader__from_batches`, batches, schema_sxp) |
| } |
| |
| RecordBatchReader__from_function <- function(fun_sexp, schema) { |
| .Call(`_arrow_RecordBatchReader__from_function`, fun_sexp, schema) |
| } |
| |
| RecordBatchReader__from_Table <- function(table) { |
| .Call(`_arrow_RecordBatchReader__from_Table`, table) |
| } |
| |
| Table__from_RecordBatchReader <- function(reader) { |
| .Call(`_arrow_Table__from_RecordBatchReader`, reader) |
| } |
| |
| RecordBatchReader__Head <- function(reader, num_rows) { |
| .Call(`_arrow_RecordBatchReader__Head`, reader, num_rows) |
| } |
| |
| MakeSafeRecordBatchReader <- function(reader) { |
| .Call(`_arrow_MakeSafeRecordBatchReader`, reader) |
| } |
| |
| ipc___RecordBatchStreamReader__Open <- function(stream) { |
| .Call(`_arrow_ipc___RecordBatchStreamReader__Open`, stream) |
| } |
| |
| 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) |
| } |
| |
| 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, 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) |
| } |
| |
| InitializeMainRThread <- function() { |
| invisible(.Call(`_arrow_InitializeMainRThread`)) |
| } |
| |
| DeinitializeMainRThread <- function() { |
| invisible(.Call(`_arrow_DeinitializeMainRThread`)) |
| } |
| |
| SetEnableSignalStopSource <- function(enabled) { |
| .Call(`_arrow_SetEnableSignalStopSource`, enabled) |
| } |
| |
| CanRunWithCapturedR <- function() { |
| .Call(`_arrow_CanRunWithCapturedR`) |
| } |
| |
| TestSafeCallIntoR <- function(r_fun_that_returns_a_string, opt) { |
| .Call(`_arrow_TestSafeCallIntoR`, r_fun_that_returns_a_string, opt) |
| } |
| |
| Array__GetScalar <- function(x, i) { |
| .Call(`_arrow_Array__GetScalar`, x, i) |
| } |
| |
| Scalar__ToString <- function(s) { |
| .Call(`_arrow_Scalar__ToString`, s) |
| } |
| |
| StructScalar__field <- function(s, i) { |
| .Call(`_arrow_StructScalar__field`, s, i) |
| } |
| |
| StructScalar__GetFieldByName <- function(s, name) { |
| .Call(`_arrow_StructScalar__GetFieldByName`, s, name) |
| } |
| |
| MakeArrayFromScalar <- function(scalar, n) { |
| .Call(`_arrow_MakeArrayFromScalar`, scalar, n) |
| } |
| |
| Scalar__is_valid <- function(s) { |
| .Call(`_arrow_Scalar__is_valid`, s) |
| } |
| |
| Scalar__type <- function(s) { |
| .Call(`_arrow_Scalar__type`, s) |
| } |
| |
| Scalar__Equals <- function(lhs, rhs) { |
| .Call(`_arrow_Scalar__Equals`, lhs, rhs) |
| } |
| |
| Scalar__ApproxEquals <- function(lhs, rhs) { |
| .Call(`_arrow_Scalar__ApproxEquals`, lhs, rhs) |
| } |
| |
| Schema__from_fields <- function(fields) { |
| .Call(`_arrow_Schema__from_fields`, fields) |
| } |
| |
| Schema__from_list <- function(field_list) { |
| .Call(`_arrow_Schema__from_list`, field_list) |
| } |
| |
| 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__AddField <- function(s, i, field) { |
| .Call(`_arrow_Schema__AddField`, s, i, field) |
| } |
| |
| Schema__SetField <- function(s, i, field) { |
| .Call(`_arrow_Schema__SetField`, s, i, field) |
| } |
| |
| Schema__RemoveField <- function(s, i) { |
| .Call(`_arrow_Schema__RemoveField`, s, i) |
| } |
| |
| Schema__GetFieldByName <- function(s, x) { |
| .Call(`_arrow_Schema__GetFieldByName`, s, x) |
| } |
| |
| Schema__fields <- function(schema) { |
| .Call(`_arrow_Schema__fields`, schema) |
| } |
| |
| Schema__field_names <- function(schema) { |
| .Call(`_arrow_Schema__field_names`, schema) |
| } |
| |
| Schema__HasMetadata <- function(schema) { |
| .Call(`_arrow_Schema__HasMetadata`, schema) |
| } |
| |
| Schema__metadata <- function(schema) { |
| .Call(`_arrow_Schema__metadata`, schema) |
| } |
| |
| Schema__WithMetadata <- function(schema, metadata) { |
| .Call(`_arrow_Schema__WithMetadata`, schema, metadata) |
| } |
| |
| Schema__WithNames <- function(schema, names) { |
| .Call(`_arrow_Schema__WithNames`, schema, names) |
| } |
| |
| Schema__serialize <- function(schema) { |
| .Call(`_arrow_Schema__serialize`, schema) |
| } |
| |
| Schema__Equals <- function(schema, other, check_metadata) { |
| .Call(`_arrow_Schema__Equals`, schema, other, check_metadata) |
| } |
| |
| arrow__UnifySchemas <- function(schemas) { |
| .Call(`_arrow_arrow__UnifySchemas`, schemas) |
| } |
| |
| 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__ReplaceSchemaMetadata <- function(x, metadata) { |
| .Call(`_arrow_Table__ReplaceSchemaMetadata`, x, metadata) |
| } |
| |
| Table__column <- function(table, i) { |
| .Call(`_arrow_Table__column`, table, i) |
| } |
| |
| Table__field <- function(table, i) { |
| .Call(`_arrow_Table__field`, table, i) |
| } |
| |
| Table__columns <- function(table) { |
| .Call(`_arrow_Table__columns`, table) |
| } |
| |
| Table__ColumnNames <- function(table) { |
| .Call(`_arrow_Table__ColumnNames`, table) |
| } |
| |
| Table__RenameColumns <- function(table, names) { |
| .Call(`_arrow_Table__RenameColumns`, table, names) |
| } |
| |
| Table__Slice1 <- function(table, offset) { |
| .Call(`_arrow_Table__Slice1`, table, offset) |
| } |
| |
| Table__Slice2 <- function(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) |
| } |
| |
| Table__Validate <- function(table) { |
| .Call(`_arrow_Table__Validate`, table) |
| } |
| |
| Table__ValidateFull <- function(table) { |
| .Call(`_arrow_Table__ValidateFull`, table) |
| } |
| |
| Table__GetColumnByName <- function(table, name) { |
| .Call(`_arrow_Table__GetColumnByName`, table, name) |
| } |
| |
| Table__RemoveColumn <- function(table, i) { |
| .Call(`_arrow_Table__RemoveColumn`, table, i) |
| } |
| |
| Table__AddColumn <- function(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) |
| } |
| |
| Table__SelectColumns <- function(table, indices) { |
| .Call(`_arrow_Table__SelectColumns`, table, indices) |
| } |
| |
| all_record_batches <- function(lst) { |
| .Call(`_arrow_all_record_batches`, lst) |
| } |
| |
| Table__from_record_batches <- function(batches, schema_sxp) { |
| .Call(`_arrow_Table__from_record_batches`, batches, schema_sxp) |
| } |
| |
| Table__from_schema <- function(schema) { |
| .Call(`_arrow_Table__from_schema`, schema) |
| } |
| |
| Table__ReferencedBufferSize <- function(table) { |
| .Call(`_arrow_Table__ReferencedBufferSize`, table) |
| } |
| |
| Table__ConcatenateTables <- function(tables, unify_schemas) { |
| .Call(`_arrow_Table__ConcatenateTables`, tables, unify_schemas) |
| } |
| |
| GetCpuThreadPoolCapacity <- function() { |
| .Call(`_arrow_GetCpuThreadPoolCapacity`) |
| } |
| |
| SetCpuThreadPoolCapacity <- function(threads) { |
| invisible(.Call(`_arrow_SetCpuThreadPoolCapacity`, threads)) |
| } |
| |
| GetIOThreadPoolCapacity <- function() { |
| .Call(`_arrow_GetIOThreadPoolCapacity`) |
| } |
| |
| SetIOThreadPoolCapacity <- function(threads) { |
| invisible(.Call(`_arrow_SetIOThreadPoolCapacity`, threads)) |
| } |
| |
| Array__infer_type <- function(x) { |
| .Call(`_arrow_Array__infer_type`, x) |
| } |
| |