tiledb.h
tiledb_version.h
tiledb_export.h
stdint.h
stdio.h
tiledb_enum.h
tiledb_version.h
stdint.h
/build/tiledb-zH8ZBi/tiledb-2.6.2/tiledb/sm/c_api/tiledb.h
tiledb_export.h
tiledb_enum.h
stdio.h
Return codes
TILEDB_OK
0

Success

TILEDB_ERR
(-1)

General error

TILEDB_OOM
(-2)

Out of memory

Constants wrapping special functions
TILEDB_COORDS
tiledb_coords
()

A special name indicating the coordinates attribute.

TILEDB_VAR_NUM
tiledb_var_num
()

A special value indicating a variable number of elements.

TILEDB_MAX_PATH
tiledb_max_path
()

The maximum path length on the current platform.

TILEDB_OFFSET_SIZE
tiledb_offset_size
()

The size (in bytes) of an offset (used in variable-sized attributes).

TILEDB_TIMESTAMP_NOW_MS
tiledb_timestamp_now_ms
()

The current time in milliseconds.

TILEDB_OBJECT_TYPE_ENUM
id
TILEDB_##id

Helper macro for defining object type enums.

TILEDB_QUERY_TYPE_ENUM
id
TILEDB_##id

Helper macro for defining query type enums.

TILEDB_QUERY_STATUS_ENUM
id
TILEDB_##id

Helper macro for defining query status enums.

TILEDB_QUERY_CONDITION_OP_ENUM
id
TILEDB_##id

Helper macro for defining query condition operator enums.

TILEDB_QUERY_CONDITION_COMBINATION_OP_ENUM
id
TILEDB_##id

Helper macro for defining query condition combination operator enums.

TILEDB_FILESYSTEM_ENUM
id
TILEDB_##id

Helper macro for defining filesystem enums.

TILEDB_DATATYPE_ENUM
id
TILEDB_##id

Helper macro for defining datatype enums.

TILEDB_ARRAY_TYPE_ENUM
id
TILEDB_##id

Helper macro for defining array type enums.

TILEDB_LAYOUT_ENUM
id
TILEDB_##id

Helper macro for defining layout type enums.

TILEDB_FILTER_TYPE_ENUM
id
TILEDB_##id

Helper macro for defining filter type enums.

TILEDB_FILTER_OPTION_ENUM
id
TILEDB_##id

Helper macro for defining filter option enums.

TILEDB_ENCRYPTION_TYPE_ENUM
id
TILEDB_##id

Helper macro for defining encryption enums.

TILEDB_WALK_ORDER_ENUM
id
TILEDB_##id

Helper macro for defining walk order enums.

TILEDB_VFS_MODE_ENUM
id
TILEDB_##id

Helper macro for defining VFS mode enums.

tiledb_object_t

TileDB object type.

tiledb_query_type_t

TileDB query type.

tiledb_query_status_t

Query status.

tiledb_query_condition_op_t

Query condition operator.

tiledb_query_condition_combination_op_t

Query condition combination operator.

tiledb_filesystem_t

Filesystem type.

tiledb_datatype_t

TileDB datatype.

tiledb_array_type_t

Array type.

tiledb_layout_t

Tile or cell layout.

tiledb_filter_type_t

Filter type.

tiledb_filter_option_t

Filter option.

tiledb_encryption_type_t

Encryption type.

tiledb_walk_order_t

Walk traversal order.

tiledb_vfs_mode_t

VFS mode.

struct tiledb_array_t typedef struct tiledb_array_t tiledb_array_t tiledb_array_t

An array object.

struct tiledb_buffer_t typedef struct tiledb_buffer_t tiledb_buffer_t tiledb_buffer_t

A generic buffer object.

struct tiledb_buffer_list_t typedef struct tiledb_buffer_list_t tiledb_buffer_list_t tiledb_buffer_list_t

A generic buffer list object.

struct tiledb_config_t typedef struct tiledb_config_t tiledb_config_t tiledb_config_t

A config object.

struct tiledb_config_iter_t typedef struct tiledb_config_iter_t tiledb_config_iter_t tiledb_config_iter_t

A config iterator.

struct tiledb_ctx_t typedef struct tiledb_ctx_t tiledb_ctx_t tiledb_ctx_t

A TileDB context.

struct tiledb_error_t typedef struct tiledb_error_t tiledb_error_t tiledb_error_t

A TileDB error.

struct tiledb_attribute_t typedef struct tiledb_attribute_t tiledb_attribute_t tiledb_attribute_t

A TileDB attribute.

struct tiledb_array_schema_t typedef struct tiledb_array_schema_t tiledb_array_schema_t tiledb_array_schema_t

A TileDB array schema.

struct tiledb_dimension_t typedef struct tiledb_dimension_t tiledb_dimension_t tiledb_dimension_t

A TileDB dimension.

struct tiledb_domain_t typedef struct tiledb_domain_t tiledb_domain_t tiledb_domain_t

A TileDB domain.

struct tiledb_filter_t typedef struct tiledb_filter_t tiledb_filter_t tiledb_filter_t

A TileDB filter.

struct tiledb_filter_list_t typedef struct tiledb_filter_list_t tiledb_filter_list_t tiledb_filter_list_t

A TileDB filter list.

struct tiledb_query_t typedef struct tiledb_query_t tiledb_query_t tiledb_query_t

A TileDB query.

struct tiledb_query_condition_t typedef struct tiledb_query_condition_t tiledb_query_condition_t tiledb_query_condition_t

A TileDB query condition object.

struct tiledb_vfs_t typedef struct tiledb_vfs_t tiledb_vfs_t tiledb_vfs_t

A virtual filesystem object.

struct tiledb_vfs_fh_t typedef struct tiledb_vfs_fh_t tiledb_vfs_fh_t tiledb_vfs_fh_t

A virtual filesystem file handle.

struct tiledb_fragment_info_t typedef struct tiledb_fragment_info_t tiledb_fragment_info_t tiledb_fragment_info_t

A fragment info object.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_type_to_str (tiledb_query_type_t query_type, const char **str) tiledb_query_type_to_str tiledb_query_type_t query_type const char ** str

Returns a string representation of the given query type.

query_type

Query type

str

Set to point to a constant string representation of the query type

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_type_from_str (const char *str, tiledb_query_type_t *query_type) tiledb_query_type_from_str const char * str tiledb_query_type_t * query_type

Parses a query type from the given string.

str

String representation to parse

query_type

Set to the parsed query type

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_object_type_to_str (tiledb_object_t object_type, const char **str) tiledb_object_type_to_str tiledb_object_t object_type const char ** str

Returns a string representation of the given object type.

object_type

Object type

str

Set to point to a constant string representation of the object type

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_object_type_from_str (const char *str, tiledb_object_t *object_type) tiledb_object_type_from_str const char * str tiledb_object_t * object_type

Parses a object type from the given string.

str

String representation to parse

object_type

Set to the parsed object type

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filesystem_to_str (tiledb_filesystem_t filesystem, const char **str) tiledb_filesystem_to_str tiledb_filesystem_t filesystem const char ** str

Returns a string representation of the given filesystem.

filesystem

Filesystem

str

Set to point to a constant string representation of the filesystem

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filesystem_from_str (const char *str, tiledb_filesystem_t *filesystem) tiledb_filesystem_from_str const char * str tiledb_filesystem_t * filesystem

Parses a filesystem from the given string.

str

String representation to parse

filesystem

Set to the parsed filesystem

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_datatype_to_str (tiledb_datatype_t datatype, const char **str) tiledb_datatype_to_str tiledb_datatype_t datatype const char ** str

Returns a string representation of the given datatype.

datatype

Datatype

str

Set to point to a constant string representation of the datatype

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_datatype_from_str (const char *str, tiledb_datatype_t *datatype) tiledb_datatype_from_str const char * str tiledb_datatype_t * datatype

Parses a datatype from the given string.

str

String representation to parse

datatype

Set to the parsed datatype

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_type_to_str (tiledb_array_type_t array_type, const char **str) tiledb_array_type_to_str tiledb_array_type_t array_type const char ** str

Returns a string representation of the given array type.

array_type

Array type

str

Set to point to a constant string representation of the array type

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_type_from_str (const char *str, tiledb_array_type_t *array_type) tiledb_array_type_from_str const char * str tiledb_array_type_t * array_type

Parses a array type from the given string.

str

String representation to parse

array_type

Set to the parsed array type

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_layout_to_str (tiledb_layout_t layout, const char **str) tiledb_layout_to_str tiledb_layout_t layout const char ** str

Returns a string representation of the given layout.

layout

Layout

str

Set to point to a constant string representation of the layout

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_layout_from_str (const char *str, tiledb_layout_t *layout) tiledb_layout_from_str const char * str tiledb_layout_t * layout

Parses a layout from the given string.

str

String representation to parse

layout

Set to the parsed layout

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_type_to_str (tiledb_filter_type_t filter_type, const char **str) tiledb_filter_type_to_str tiledb_filter_type_t filter_type const char ** str

Returns a string representation of the given filter type.

filter_type

Filter type

str

Set to point to a constant string representation of the filter type

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_type_from_str (const char *str, tiledb_filter_type_t *filter_type) tiledb_filter_type_from_str const char * str tiledb_filter_type_t * filter_type

Parses a filter type from the given string.

str

String representation to parse

filter_type

Set to the parsed filter type

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_option_to_str (tiledb_filter_option_t filter_option, const char **str) tiledb_filter_option_to_str tiledb_filter_option_t filter_option const char ** str

Returns a string representation of the given filter option.

filter_option

Filter option

str

Set to point to a constant string representation of the filter option

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_option_from_str (const char *str, tiledb_filter_option_t *filter_option) tiledb_filter_option_from_str const char * str tiledb_filter_option_t * filter_option

Parses a filter option from the given string.

str

String representation to parse

filter_option

Set to the parsed filter option

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_encryption_type_to_str (tiledb_encryption_type_t encryption_type, const char **str) tiledb_encryption_type_to_str tiledb_encryption_type_t encryption_type const char ** str

Returns a string representation of the given encryption type.

encryption_type

Encryption type

str

Set to point to a constant string representation of the encryption type

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_encryption_type_from_str (const char *str, tiledb_encryption_type_t *encryption_type) tiledb_encryption_type_from_str const char * str tiledb_encryption_type_t * encryption_type

Parses a encryption type from the given string.

str

String representation to parse

encryption_type

Set to the parsed encryption type

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_status_to_str (tiledb_query_status_t query_status, const char **str) tiledb_query_status_to_str tiledb_query_status_t query_status const char ** str

Returns a string representation of the given query status.

query_status

Query status

str

Set to point to a constant string representation of the query status

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_status_from_str (const char *str, tiledb_query_status_t *query_status) tiledb_query_status_from_str const char * str tiledb_query_status_t * query_status

Parses a query status from the given string.

str

String representation to parse

query_status

Set to the parsed query status

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_walk_order_to_str (tiledb_walk_order_t walk_order, const char **str) tiledb_walk_order_to_str tiledb_walk_order_t walk_order const char ** str

Returns a string representation of the given walk order.

walk_order

Walk order

str

Set to point to a constant string representation of the walk order

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_walk_order_from_str (const char *str, tiledb_walk_order_t *walk_order) tiledb_walk_order_from_str const char * str tiledb_walk_order_t * walk_order

Parses a walk order from the given string.

str

String representation to parse

walk_order

Set to the parsed walk order

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_mode_to_str (tiledb_vfs_mode_t vfs_mode, const char **str) tiledb_vfs_mode_to_str tiledb_vfs_mode_t vfs_mode const char ** str

Returns a string representation of the given VFS mode.

vfs_mode

VFS mode

str

Set to point to a constant string representation of the VFS mode

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_mode_from_str (const char *str, tiledb_vfs_mode_t *vfs_mode) tiledb_vfs_mode_from_str const char * str tiledb_vfs_mode_t * vfs_mode

Parses a VFS mode from the given string.

str

String representation to parse

vfs_mode

Set to the parsed VFS mode

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT const char * TILEDB_DEPRECATED_EXPORT const char* tiledb_coords (void) tiledb_coords void

Returns a special name indicating the coordinates attribute.

The coordinate buffer has been deprecated. Set the coordinates for each individual dimension with the `set_buffer` API. Consult the current documentation for more information.

TILEDB_EXPORT uint32_t TILEDB_EXPORT uint32_t tiledb_var_num (void) tiledb_var_num void

Returns a special value indicating a variable number of elements.

TILEDB_EXPORT uint32_t TILEDB_EXPORT uint32_t tiledb_max_path (void) tiledb_max_path void

Returns the maximum path length on the current platform.

TILEDB_EXPORT uint64_t TILEDB_EXPORT uint64_t tiledb_datatype_size (tiledb_datatype_t type) tiledb_datatype_size tiledb_datatype_t type

Returns the input datatype size.

TILEDB_EXPORT uint64_t TILEDB_EXPORT uint64_t tiledb_offset_size (void) tiledb_offset_size void

Returns the size (in bytes) of an offset (used in variable-sized attributes).

TILEDB_EXPORT uint64_t TILEDB_EXPORT uint64_t tiledb_timestamp_now_ms (void) tiledb_timestamp_now_ms void

Returns the current time in milliseconds.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_version (int32_t *major, int32_t *minor, int32_t *rev) tiledb_version int32_t * major int32_t * minor int32_t * rev

Retrieves the version of the TileDB library currently being used.

major

Will store the major version number.

minor

Will store the minor version number.

rev

Will store the revision (patch) number.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_error_message (tiledb_error_t *err, const char **errmsg) tiledb_error_message tiledb_error_t * err const char ** errmsg

Returns the error message associated with a TileDB error object.

Example:

The following shows how to get the last error from a TileDB context.

    tiledb_error_t*err=NULL;
    tiledb_ctx_get_last_error(ctx,&err);
    constchar*msg;
    tiledb_error_message(err,&msg);
    printf("%s\n",msg);

err

A TileDB error object.

errmsg

A constant pointer to the error message.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_error_free (tiledb_error_t **err) tiledb_error_free tiledb_error_t ** err

Frees the resources associated with a TileDB error object.

Example:

    tiledb_error_t*err=NULL;
    tiledb_ctx_get_last_error(ctx,&err);
    constchar*msg;
    tiledb_error_message(err,&msg);
    printf("%s\n",msg);
    tiledb_error_free(&err);

err

The TileDB error object.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_buffer_alloc (tiledb_ctx_t *ctx, tiledb_buffer_t **buffer) tiledb_buffer_alloc tiledb_ctx_t * ctx tiledb_buffer_t ** buffer

Creates an empty buffer object.

Example:

    tiledb_buffer_t*buffer;
    tiledb_buffer_alloc(ctx,&buffer);

ctx

TileDB context

buffer

The buffer to be created

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_buffer_free (tiledb_buffer_t **buffer) tiledb_buffer_free tiledb_buffer_t ** buffer

Destroys a TileDB buffer, freeing associated memory.

Example:

    tiledb_buffer_t*buffer;
    tiledb_buffer_alloc(ctx,&buffer);
    tiledb_buffer_free(&buffer);

buffer

The buffer to be destroyed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_buffer_set_type (tiledb_ctx_t *ctx, tiledb_buffer_t *buffer, tiledb_datatype_t datatype) tiledb_buffer_set_type tiledb_ctx_t * ctx tiledb_buffer_t * buffer tiledb_datatype_t datatype

Sets a datatype for the given buffer. The default datatype is `TILEDB_UINT8`.

Example:

    tiledb_buffer_t*buffer;
    tiledb_buffer_alloc(ctx,&buffer);
    tiledb_buffer_set_type(ctx,buffer,TILEDB_INT32);

ctx

TileDB context

buffer

TileDB buffer instance

datatype

The datatype to set on the buffer.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_buffer_get_type (tiledb_ctx_t *ctx, const tiledb_buffer_t *buffer, tiledb_datatype_t *datatype) tiledb_buffer_get_type tiledb_ctx_t * ctx const tiledb_buffer_t * buffer tiledb_datatype_t * datatype

Gets the datatype from the given buffer.

Example:

    tiledb_datatype_ttype;
    tiledb_buffer_get_type(ctx,buffer,&type);

ctx

TileDB context

buffer

TileDB buffer instance

datatype

Set to the datatype of the buffer.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_buffer_get_data (tiledb_ctx_t *ctx, const tiledb_buffer_t *buffer, void **data, uint64_t *num_bytes) tiledb_buffer_get_data tiledb_ctx_t * ctx const tiledb_buffer_t * buffer void ** data uint64_t * num_bytes

Gets a pointer to the current allocation and the current number of bytes in the specified buffer object.

For string buffers allocated by TileDB, the number of bytes includes the terminating NULL byte.

Example:

    tiledb_buffer_t*buffer;
    tiledb_buffer_alloc(ctx,&buffer);
    void*data;
    uint64_tnum_bytes;
    tiledb_buffer_get_data(ctx,buffer,&data,num_bytes);
    //data==NULLandnum_bytes==0becausethebufferiscurrentlyempty.
    tiledb_buffer_free(&buffer);

ctx

TileDB context

buffer

TileDB buffer instance

data

The pointer to the data to be retrieved.

num_bytes

Set to the number of bytes in the buffer.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_buffer_set_data (tiledb_ctx_t *ctx, tiledb_buffer_t *buffer, void *data, uint64_t size) tiledb_buffer_set_data tiledb_ctx_t * ctx tiledb_buffer_t * buffer void * data uint64_t size

Sets (wraps) a pre-allocated region of memory with the given buffer object. This does not perform a copy.

The TileDB buffer object does not take ownership of the allocation set with this function. That means the call to `tiledb_buffer_free` will not free a user allocation set via `tiledb_buffer_set_buffer`.

Example:

    tiledb_buffer_t*buffer;
    tiledb_buffer_alloc(ctx,&buffer);

    void*my_data=malloc(100);
    tiledb_buffer_set_data(ctx,buffer,my_data,100);

    void*data;
    uint64_tnum_bytes;
    tiledb_buffer_get_data(ctx,buffer,&data,num_bytes);
    assert(data==my_data);
    assert(num_bytes==100);

    tiledb_buffer_free(&buffer);
    free(my_data);

ctx

TileDB context

buffer

TileDB buffer instance

data

Pre-allocated region of memory to wrap with this buffer.

size

Size (in bytes) of the region pointed to by data.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_buffer_list_alloc (tiledb_ctx_t *ctx, tiledb_buffer_list_t **buffer_list) tiledb_buffer_list_alloc tiledb_ctx_t * ctx tiledb_buffer_list_t ** buffer_list

Creates an empty buffer list object.

Example:

    tiledb_buffer_list_t*buffer_list;
    tiledb_buffer_list_alloc(ctx,&buffer_list);

ctx

TileDB context

buffer_list

The buffer list to be created

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_buffer_list_free (tiledb_buffer_list_t **buffer_list) tiledb_buffer_list_free tiledb_buffer_list_t ** buffer_list

Destroys a TileDB buffer list, freeing associated memory.

Example:

    tiledb_buffer_t*buffer_list;
    tiledb_buffer_list_alloc(ctx,&buffer_list);
    tiledb_buffer_list_free(&buffer_list);

buffer_list

The buffer list to be destroyed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_buffer_list_get_num_buffers (tiledb_ctx_t *ctx, const tiledb_buffer_list_t *buffer_list, uint64_t *num_buffers) tiledb_buffer_list_get_num_buffers tiledb_ctx_t * ctx const tiledb_buffer_list_t * buffer_list uint64_t * num_buffers

Gets the number of buffers in the buffer list.

Example:

    tiledb_buffer_list_t*buffer_list;
    tiledb_buffer_list_alloc(ctx,&buffer_list);
    uint64_tnum_buffers;
    tiledb_buffer_list_get_num_buffers(ctx,buffer_list,&num_buffers);
    //num_buffers==0becausethelistisempty.

ctx

TileDB context.

buffer_list

The buffer list.

num_buffers

Set to the number of buffers in the buffer list.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_buffer_list_get_buffer (tiledb_ctx_t *ctx, const tiledb_buffer_list_t *buffer_list, uint64_t buffer_idx, tiledb_buffer_t **buffer) tiledb_buffer_list_get_buffer tiledb_ctx_t * ctx const tiledb_buffer_list_t * buffer_list uint64_t buffer_idx tiledb_buffer_t ** buffer

Gets the buffer at the given index in the buffer list. The returned buffer object is simply a pointer to memory managed by the underlying buffer list, meaning this function does not perform a copy.

It is the caller's responsibility to free the returned buffer with `tiledb_buffer_free`. Since the returned buffer object does not "own" the underlying allocation, the underlying allocation is not freed when freeing it with `tiledb_buffer_free`.

Example:

    tiledb_buffer_list_t*buffer_list;
    //Createandpopulatethebuffer_list

    //Getthebufferatindex0.
    tiledb_buffer_t*buff0;
    tiledb_buffer_list_get_buffer(ctx,buffer_list,0,&buff0);

    //Alwaysfreethereturnedbufferobject
    tiledb_buffer_free(&buff0);
    tiledb_buffer_list_free(&buffer_list);

ctx

TileDB context.

buffer_list

The buffer list.

buffer_idx

Index of buffer to get from the buffer list.

buffer

Set to a newly allocated buffer object pointing to the underlying allocation in the buffer list corresponding to the buffer.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_buffer_list_get_total_size (tiledb_ctx_t *ctx, const tiledb_buffer_list_t *buffer_list, uint64_t *total_size) tiledb_buffer_list_get_total_size tiledb_ctx_t * ctx const tiledb_buffer_list_t * buffer_list uint64_t * total_size

Gets the total number of bytes in the buffers in the buffer list.

Example:

    tiledb_buffer_list_t*buffer_list;
    tiledb_buffer_list_alloc(ctx,&buffer_list);
    uint64_ttotal_size;
    tiledb_buffer_list_get_total_size(ctx,buffer_list,&total_size);
    //total_size==0becausethelistisempty.

ctx

TileDB context.

buffer_list

The buffer list.

total_size

Set to the total number of bytes in the buffers in the buffer list.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_buffer_list_flatten (tiledb_ctx_t *ctx, const tiledb_buffer_list_t *buffer_list, tiledb_buffer_t **buffer) tiledb_buffer_list_flatten tiledb_ctx_t * ctx const tiledb_buffer_list_t * buffer_list tiledb_buffer_t ** buffer

Copies and concatenates all the data in the buffer list into a new buffer.

Example:

    tiledb_buffer_t*buff;
    tiledb_buffer_list_flatten(ctx,buffer_list,&buff);
    //...
    tiledb_buffer_free(&buff);

ctx

TileDB context.

buffer_list

The buffer list.

buffer

Will be set to a newly allocated buffer holding a copy of the concatenated data from the buffer list.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_alloc (tiledb_config_t **config, tiledb_error_t **error) tiledb_config_alloc tiledb_config_t ** config tiledb_error_t ** error

Creates a TileDB config.

Example:

    tiledb_config_t*config;
    tiledb_error_t*error=NULL;
    tiledb_config_alloc(&config,&error);

config

The config to be created.

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_config_free (tiledb_config_t **config) tiledb_config_free tiledb_config_t ** config

Frees a TileDB config.

Example:

    tiledb_config_t*config;
    tiledb_error_t*error=NULL;
    tiledb_config_alloc(&config,&error);
    tiledb_config_free(&config);

config

The config to be freed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_set (tiledb_config_t *config, const char *param, const char *value, tiledb_error_t **error) tiledb_config_set tiledb_config_t * config const char * param const char * value tiledb_error_t ** error

Sets a config parameter.

Parameters

- `sm.dedup_coords` If `true`, cells with duplicate coordinates will be removed during sparse fragment writes. Note that ties during deduplication are broken arbitrarily. Default: false

- `sm.check_coord_dups` This is applicable only if `sm.dedup_coords` is `false`. If `true`, an error will be thrown if there are cells with duplicate coordinates during sparse fragmnet writes. If `false` and there are duplicates, the duplicates will be written without errors. Default: true

- `sm.check_coord_oob` If `true`, an error will be thrown if there are cells with coordinates lying outside the domain during sparse fragment writes. Default: true `sm.read_range_oob` If `error`, this will check ranges for read with out-of-bounds on the dimension domain's. If `warn`, the ranges will be capped at the dimension's domain and a warning logged. Default: warn

- `sm.check_global_order` Checks if the coordinates obey the global array order. Applicable only to sparse writes in global order. Default: true

- `sm.tile_cache_size` The tile cache size in bytes. Any `uint64_t` value is acceptable. Default: 10,000,000

- `sm.enable_signal_handlers` Determines whether or not TileDB will install signal handlers. Default: true

- `sm.compute_concurrency_level` Upper-bound on number of threads to allocate for compute-bound tasks. Default*: # cores

- `sm.io_concurrency_level` Upper-bound on number of threads to allocate for IO-bound tasks. **Default*: # cores

- `sm.vacuum.mode` The vacuuming mode, one of `fragments` (remove consolidated fragments), `fragment_meta` (remove only consolidated fragment metadata), or `array_meta` (remove consolidated array metadata files). **Default: fragments

- `sm.vacuum.timestamp_start` Experimental When set, an array will be vacuumed between this value and `sm.vacuum.timestamp_end` (inclusive). Only for `fragments` and `array_meta` vacuum mode. Default: 0

- `sm.vacuum.timestamp_end` Experimental When set, an array will be vacuumed between `sm.vacuum.timestamp_start` and this value (inclusive). Only for `fragments` and `array_meta` vacuum mode. Default: UINT64_MAX

- `sm.consolidation_mode` The consolidation mode, one of `fragments` (consolidate all fragments), `fragment_meta` (consolidate only fragment metadata footers to a single file), or `array_meta` (consolidate array metadata only). Default: "fragments"

- `sm.consolidation.amplification` The factor by which the size of the dense fragment resulting from consolidating a set of fragments (containing at least one dense fragment) can be amplified. This is important when the union of the non-empty domains of the fragments to be consolidated have a lot of empty cells, which the consolidated fragment will have to fill with the special fill value (since the resulting fragment is dense). Default: 1.0

- `sm.consolidation.buffer_size` The size (in bytes) of the attribute buffers used during consolidation. Default: 50,000,000

- `sm.consolidation.steps` The number of consolidation steps to be performed when executing the consolidation algorithm. Default: 1

- `sm.consolidation.step_min_frags` The minimum number of fragments to consolidate in a single step. Default: UINT32_MAX

- `sm.consolidation.step_max_frags` The maximum number of fragments to consolidate in a single step. Default: UINT32_MAX

- `sm.consolidation.step_size_ratio` The size ratio that two ("adjacent") fragments must satisfy to be considered for consolidation in a single step. Default: 0.0

- `sm.consolidation.timestamp_start` Experimental When set, an array will be consolidated between this value and `sm.consolidation.timestamp_end` (inclusive). Only for `fragments` and `array_meta` consolidation mode. Default: 0

- `sm.consolidation.timestamp_end` Experimental When set, an array will be consolidated between `sm.consolidation.timestamp_start` and this value (inclusive). Only for `fragments` and `array_meta` consolidation mode. Default: UINT64_MAX

- `sm.memory_budget` The memory budget for tiles of fixed-sized attributes (or offsets for var-sized attributes) to be fetched during reads. Default: 5GB

- `sm.memory_budget_var` The memory budget for tiles of var-sized attributes to be fetched during reads. Default: 10GB

- `sm.var_offsets.bitsize` The size of offsets in bits to be used for offset buffers of var-sized attributes Default: 64

- `sm.var_offsets.extra_element` Add an extra element to the end of the offsets buffer of var-sized attributes which will point to the end of the values buffer. Default: false

- `sm.var_offsets.mode` The offsets format (`bytes` or `elements`) to be used for var-sized attributes. Default: bytes

- `sm.query.dense.reader` Which reader to use for dense queries. "refactored" or "legacy". Default: lagacy

- `sm.query.sparse_global_order.reader` Which reader to use for sparse global order queries. "refactored" or "legacy". Default: legacy

- `sm.query.sparse_unordered_with_dups.reader` Which reader to use for sparse unordered with dups queries. "refactored" or "legacy". Default: refactored

- `sm.mem.malloc_trim` Should malloc_trim be called on context and query destruction? This might reduce residual memory usage. Default: true

- `sm.mem.total_budget` Memory budget for readers and writers. Default: 10GB

- `sm.mem.reader.sparse_global_order.ratio_coords` Ratio of the budget allocated for coordinates in the sparse global order reader. Default: 0.5

- `sm.mem.reader.sparse_global_order.ratio_query_condition` Ratio of the budget allocated for the query condition in the sparse global order reader. Default: 0.25

- `sm.mem.reader.sparse_global_order.ratio_tile_ranges` Ratio of the budget allocated for tile ranges in the sparse global order reader. Default: 0.1

- `sm.mem.reader.sparse_global_order.ratio_array_data` Ratio of the budget allocated for array data in the sparse global order reader. Default: 0.1

- `sm.mem.reader.sparse_global_order.ratio_rcs` Ratio of the budget allocated for result cell slabs in the sparse global order reader. Default: 0.05

- `sm.mem.reader.sparse_unordered_with_dups.ratio_coords` Ratio of the budget allocated for coordinates in the sparse unordered with duplicates reader. Default: 0.5

- `sm.mem.reader.sparse_unordered_with_dups.ratio_query_condition` Ratio of the budget allocated for the query condition in the sparse unordered with duplicates reader. Default: 0.25

- `sm.mem.reader.sparse_unordered_with_dups.ratio_tile_ranges` Ratio of the budget allocated for tile ranges in the sparse unordered with duplicates reader. Default: 0.1

- `sm.mem.reader.sparse_unordered_with_dups.ratio_array_data` Ratio of the budget allocated for array data in the sparse unordered with duplicates reader. Default: 0.1 The maximum byte size to read-ahead from the backend. Default: 102400

- `vfs.read_ahead_cache_size` The the total maximum size of the read-ahead cache, which is an LRU. Default: 10485760

- `vfs.min_parallel_size` The minimum number of bytes in a parallel VFS operation (except parallel S3 writes, which are controlled by `vfs.s3.multipart_part_size`). Default: 10MB

- `vfs.min_batch_size` The minimum number of bytes in a VFS read operation Default: 20MB

- `vfs.min_batch_gap` The minimum number of bytes between two VFS read batches. Default: 500KB

- `vfs.file.posix_file_permissions` Permissions to use for posix file system with file creation. Default: 644

- `vfs.file.posix_directory_permissions` Permissions to use for posix file system with directory creation. Default: 755

- `vfs.file.max_parallel_ops` The maximum number of parallel operations on objects with `file:///` URIs. Default: `sm.io_concurrency_level`

- `vfs.file.enable_filelocks` If set to `false`, file locking operations are no-ops for `file:///` URIs in VFS. Default: `true`

- `vfs.azure.storage_account_name` Set the Azure Storage Account name. Default: ""

- `vfs.azure.storage_account_key` Set the Azure Storage Account key. Default: ""

- `vfs.azure.storage_sas_token` Set the Azure Storage SAS (shared access signature) token. Default: ""

- `vfs.azure.blob_endpoint` Overrides the default Azure Storage Blob endpoint. If empty, the endpoint will be constructed from the storage account name. This should not include an http:// or https:// prefix. Default: ""

- `vfs.azure.block_list_block_size` The block size (in bytes) used in Azure blob block list writes. Any `uint64_t` value is acceptable. Note: `vfs.azure.block_list_block_size vfs.azure.max_parallel_ops` bytes will be buffered before issuing block uploads in parallel. Default: "5242880"

- `vfs.azure.max_parallel_ops` The maximum number of Azure backend parallel operations. Default: `sm.io_concurrency_level`

- `vfs.azure.use_block_list_upload` Determines if the Azure backend can use chunked block uploads. Default: "true"

- `vfs.azure.use_https` Determines if the blob endpoint should use HTTP or HTTPS. Default: "true"

- `vfs.gcs.project_id` Set the GCS project id. Default: ""

- `vfs.gcs.multi_part_size` The part size (in bytes) used in GCS multi part writes. Any `uint64_t` value is acceptable. Note: `vfs.gcs.multi_part_size * vfs.gcs.max_parallel_ops` bytes will be buffered before issuing part uploads in parallel. Default: "5242880"

- `vfs.gcs.max_parallel_ops` The maximum number of GCS backend parallel operations. Default: `sm.io_concurrency_level`

- `vfs.gcs.use_multi_part_upload` Determines if the GCS backend can use chunked part uploads. Default: "true"

- `vfs.gcs.request_timeout_ms` The maximum amount of time to retry network requests to GCS. Default: "3000"

- `vfs.s3.region` The S3 region, if S3 is enabled. Default: us-east-1

- `vfs.s3.aws_access_key_id` Set the AWS_ACCESS_KEY_ID Default: ""

- `vfs.s3.aws_secret_access_key` Set the AWS_SECRET_ACCESS_KEY Default: ""

- `vfs.s3.aws_session_token` Set the AWS_SESSION_TOKEN Default: ""

- `vfs.s3.aws_role_arn` Determines the role that we want to assume. Set the AWS_ROLE_ARN Default: ""

- `vfs.s3.aws_external_id` Third party access ID to your resources when assuming a role. Set the AWS_EXTERNAL_ID Default: ""

- `vfs.s3.aws_load_frequency` Session time limit when assuming a role. Set the AWS_LOAD_FREQUENCY Default: ""

- `vfs.s3.aws_session_name` (Optional) session name when assuming a role. Can be used for tracing and bookkeeping. Set the AWS_SESSION_NAME Default: ""

- `vfs.s3.scheme` The S3 scheme (`http` or `https`), if S3 is enabled. Default: https

- `vfs.s3.endpoint_override` The S3 endpoint, if S3 is enabled. Default: ""

- `vfs.s3.use_virtual_addressing` The S3 use of virtual addressing (`true` or `false`), if S3 is enabled. Default: true

- `vfs.s3.skip_init` Skip Aws::InitAPI for the S3 layer (`true` or `false`) Default: false

- `vfs.s3.use_multipart_upload` The S3 use of multi-part upload requests (`true` or `false`), if S3 is enabled. Default: true

- `vfs.s3.max_parallel_ops` The maximum number of S3 backend parallel operations. Default: `sm.io_concurrency_level`

- `vfs.s3.multipart_part_size` The part size (in bytes) used in S3 multipart writes. Any `uint64_t` value is acceptable. Note: `vfs.s3.multipart_part_size * vfs.s3.max_parallel_ops` bytes will be buffered before issuing multipart uploads in parallel. Default: 5MB

- `vfs.s3.ca_file` Path to SSL/TLS certificate file to be used by cURL for for S3 HTTPS encryption. Follows cURL conventions: https://curl.haxx.se/docs/manpage.html Default: ""

- `vfs.s3.ca_path` Path to SSL/TLS certificate directory to be used by cURL for S3 HTTPS encryption. Follows cURL conventions: https://curl.haxx.se/docs/manpage.html Default: ""

- `vfs.s3.connect_timeout_ms` The connection timeout in ms. Any `long` value is acceptable. Default: 3000

- `vfs.s3.connect_max_tries` The maximum tries for a connection. Any `long` value is acceptable. Default: 5

- `vfs.s3.connect_scale_factor` The scale factor for exponential backoff when connecting to S3. Any `long` value is acceptable. Default: 25

- `vfs.s3.logging_level` The AWS SDK logging level. This is a process-global setting. The configuration of the most recently constructed context will set process state. Log files are written to the process working directory. Default: ""

- `vfs.s3.request_timeout_ms` The request timeout in ms. Any `long` value is acceptable. Default: 3000

- `vfs.s3.requester_pays` The requester pays for the S3 access charges. Default: false

- `vfs.s3.proxy_host` The S3 proxy host. Default: ""

- `vfs.s3.proxy_port` The S3 proxy port. Default: 0

- `vfs.s3.proxy_scheme` The S3 proxy scheme. Default: "http"

- `vfs.s3.proxy_username` The S3 proxy username. Note: this parameter is not serialized by `tiledb_config_save_to_file`. Default: ""

- `vfs.s3.proxy_password` The S3 proxy password. Note: this parameter is not serialized by `tiledb_config_save_to_file`. Default: ""

- `vfs.s3.verify_ssl` Enable HTTPS certificate verification. Default: true""

- `vfs.s3.sse` The server-side encryption algorithm to use. Supported non-empty values are "aes256" and "kms" (AWS key management service). Default: ""

- `vfs.s3.bucket_canned_acl` Names of values found in Aws::S3::Model::BucketCannedACL enumeration. "NOT_SET" "private_" "public_read" "public_read_write" "authenticated_read" Default: "NOT_SET"

- `vfs.s3.object_canned_acl` Names of values found in Aws::S3::Model::ObjectCannedACL enumeration. (The first 5 are the same as for "vfs.s3.bucket_canned_acl".) "NOT_SET" "private_" "public_read" "public_read_write" "authenticated_read" (The following three items are found only in Aws::S3::Model::ObjectCannedACL.) "aws_exec_read" "owner_read" "bucket_owner_full_control" Default: "NOT_SET"

- `vfs.hdfs.name_node_uri"` Name node for HDFS. Default: ""

- `vfs.hdfs.username` HDFS username. Default: ""

- `vfs.hdfs.kerb_ticket_cache_path` HDFS kerb ticket cache path. Default: ""

- `config.env_var_prefix` Prefix of environmental variables for reading configuration parameters. Default: "TILEDB_"

- `config.logging_level` The logging level configured, possible values: "0": fatal, "1": error, "2": warn, "3": info "4": debug, "5": trace Default: "1" if enable-verbose bootstrap flag is provided, "0" otherwise

- `config.logging_format` The logging format configured (DEFAULT or JSON) Default: "DEFAULT"

- `rest.server_address` URL for REST server to use for remote arrays. Default: "https://api.tiledb.com"

- `rest.server_serialization_format` Serialization format to use for remote array requests (CAPNP or JSON). Default: "CAPNP"

- `rest.username` Username for login to REST server. Default: ""

- `rest.password` Password for login to REST server. Default: ""

- `rest.token` Authentication token for REST server (used instead of username/password). Default: ""

- `rest.resubmit_incomplete` If true, incomplete queries received from server are automatically resubmitted before returning to user control. Default: "true"

- `rest.ignore_ssl_validation` Have curl ignore ssl peer and host validation for REST server. Default: false

- `rest.creation_access_credentials_name` The name of the registered access key to use for creation of the REST server. Default: no default set

- `rest.retry_http_codes` CSV list of http status codes to automatically retry a REST request for Default: "503"

- `rest.retry_count` Number of times to retry failed REST requests Default: 3

- `rest.retry_initial_delay_ms` Initial delay in milliseconds to wait until retrying a REST request Default: 500

- `rest.retry_delay_factor` The delay factor to exponentially wait until further retries of a failed REST request Default: 1.25

Example:

    tiledb_error_t*error=NULL;
    tiledb_config_set(config,"sm.tile_cache_size","1000000",&error);

config

The config object.

param

The parameter to be set.

value

The value of the parameter to be set.

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_get (tiledb_config_t *config, const char *param, const char **value, tiledb_error_t **error) tiledb_config_get tiledb_config_t * config const char * param const char ** value tiledb_error_t ** error

Gets a config parameter.

Example:

    constchar*value;
    tiledb_error_t*error=NULL;
    tiledb_config_get(config,"sm.tile_cache_size",&value,&error);

config

The config object.

param

The parameter to be set.

value

A pointer to the value of the parameter to be retrieved (`NULL` if it does not exist).

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_load_from_file (tiledb_config_t *config, const char *filename, tiledb_error_t **error) tiledb_config_load_from_file tiledb_config_t * config const char * filename tiledb_error_t ** error

Loads config parameters from a (local) text file.

Example:

    tiledb_error_t*error=NULL;
    tiledb_config_load_from_file(config,"tiledb.conf",&error);

config

The config object.

filename

The name of the file.

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_unset (tiledb_config_t *config, const char *param, tiledb_error_t **error) tiledb_config_unset tiledb_config_t * config const char * param tiledb_error_t ** error

Unsets a config parameter. This will set the config parameter to its default value.

Example:

    tiledb_error_t*error=NULL;
    tiledb_config_unset(config,"sm.tile_cache_size",&error);

config

The config object.

param

The parameter to be unset.

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_save_to_file (tiledb_config_t *config, const char *filename, tiledb_error_t **error) tiledb_config_save_to_file tiledb_config_t * config const char * filename tiledb_error_t ** error

Saves the config parameters to a (local) text file.

Example:

    tiledb_error_t*error=NULL;
    tiledb_config_save_to_file(config,"tiledb.conf",&error);

config

The config object.

filename

The name of the file.

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_compare (tiledb_config_t *lhs, tiledb_config_t *rhs, uint8_t *equal) tiledb_config_compare tiledb_config_t * lhs tiledb_config_t * rhs uint8_t * equal

Compares 2 configurations for equality

Example:

    tiledb_error_terror;
    uint8_tequal;
    tiledb_config_compare(lhs,rhs,&equal);

lhs

The left-hand side config object.

rhs

The right-hand side config object.

equal

Integer of equality comparison 1 = true, 0 = false

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_iter_alloc (tiledb_config_t *config, const char *prefix, tiledb_config_iter_t **config_iter, tiledb_error_t **error) tiledb_config_iter_alloc tiledb_config_t * config const char * prefix tiledb_config_iter_t ** config_iter tiledb_error_t ** error

Creates an iterator on a config object.

Examples:

The following creates a config iterator without a prefix. This will iterate over all config param/values.

    tiledb_error_t*error=NULL;
    tiledb_config_iter_t*config_iter;
    tiledb_config_iter_alloc(config,NULL,&config_iter,&error);

The following creates a config iterator with a prefix. This will iterate over all S3 config param/values, stripping out `vfs.s3.`. For instance, instead of retrieving `vfs.s3.region` as a parameter via `tiledb_config_iter_here`, it will retrieve `region`.

    tiledb_error_t*error=NULL;
    tiledb_config_iter_t*config_iter;
    tiledb_config_iter_alloc(config,"vfs.s3.",&config_iter,&error);

config

A config object the iterator will operate on.

prefix

If not `NULL`, only the config parameters starting with `prefix*` will be iterated on. Moreover, the prefix will be stripped from the parameters. Otherwise, all parameters will be iterated on and their full name will be retrieved.

config_iter

The config iterator to be created.

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_iter_reset (tiledb_config_t *config, tiledb_config_iter_t *config_iter, const char *prefix, tiledb_error_t **error) tiledb_config_iter_reset tiledb_config_t * config tiledb_config_iter_t * config_iter const char * prefix tiledb_error_t ** error

Resets the iterator.

Examples:

Without a prefix:

    tiledb_config_iter_reset(config,config_iter,NULL,&error);

With a prefix:

    tiledb_config_iter_reset(config,config_iter,"vfs.s3.",&error);

config

A config object the iterator will operate on.

config_iter

The config iterator to be reset.

prefix

If not `NULL`, only the config parameters starting with `prefix*` will be iterated on. Moreover, the prefix will be stripped from the parameters. Otherwise, all parameters will be iterated on and their full name will be retrieved.

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_config_iter_free (tiledb_config_iter_t **config_iter) tiledb_config_iter_free tiledb_config_iter_t ** config_iter

Frees a config iterator.

Example:

    tiledb_config_iter_free(&config_iter);

config_iter

The config iterator to be freed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_iter_here (tiledb_config_iter_t *config_iter, const char **param, const char **value, tiledb_error_t **error) tiledb_config_iter_here tiledb_config_iter_t * config_iter const char ** param const char ** value tiledb_error_t ** error

Retrieves the config param and value currently pointed by the iterator.

Example:

    constchar*param,*value;
    tiledb_config_iter_here(config_iter,&param,&value,&error);

config_iter

The config iterator.

param

The config parameter to be retrieved (`NULL` if the iterator is at the end).

value

The config value to be retrieved (`NULL` if the iterator is at the end).

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_iter_next (tiledb_config_iter_t *config_iter, tiledb_error_t **error) tiledb_config_iter_next tiledb_config_iter_t * config_iter tiledb_error_t ** error

Moves the iterator to the next param.

Example:

    tiledb_config_iter_next(config_iter,&error);

config_iter

The config iterator.

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_config_iter_done (tiledb_config_iter_t *config_iter, int32_t *done, tiledb_error_t **error) tiledb_config_iter_done tiledb_config_iter_t * config_iter int32_t * done tiledb_error_t ** error

Checks if the iterator is done.

Example:

    int32_tdone;
    tiledb_config_iter_done(config_iter,&done,&error);

config_iter

The config iterator.

done

Sets this to `1` if the iterator is done, `0` otherwise.

error

Error object returned upon error (`NULL` if there is no error).

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_ctx_alloc (tiledb_config_t *config, tiledb_ctx_t **ctx) tiledb_ctx_alloc tiledb_config_t * config tiledb_ctx_t ** ctx

Creates a TileDB context, which contains the TileDB storage manager that manages everything in the TileDB library.

Examples:

Without config (i.e., use default configuration):

    tiledb_ctx_t*ctx;
    tiledb_ctx_alloc(NULL,&ctx);

With some config:

    tiledb_ctx_t*ctx;
    tiledb_ctx_alloc(config,&ctx);

config

The configuration parameters (`NULL` means default).

ctx

The TileDB context to be created.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_ctx_free (tiledb_ctx_t **ctx) tiledb_ctx_free tiledb_ctx_t ** ctx

Destroys the TileDB context, freeing all associated memory and resources.

Example:

    tiledb_ctx_t*ctx;
    tiledb_ctx_alloc(NULL,&ctx);
    tiledb_ctx_free(&ctx);

ctx

The TileDB context to be freed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_ctx_get_stats (tiledb_ctx_t *ctx, char **stats_json) tiledb_ctx_get_stats tiledb_ctx_t * ctx char ** stats_json

Retrieves the stats from a TileDB context.

Example:

    char*stats_json;
    tiledb_ctx_get_stats(ctx,&stats_json);
    //Makesuretofreetheretrieved`stats_json`

ctx

The TileDB context.

stats_json

The output json. The caller takes ownership of the c-string.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_ctx_get_config (tiledb_ctx_t *ctx, tiledb_config_t **config) tiledb_ctx_get_config tiledb_ctx_t * ctx tiledb_config_t ** config

Retrieves a copy of the config from a TileDB context. Modifying this config will not affect the initialized context configuration.

Example:

    tiledb_config_t*config;
    tiledb_ctx_get_config(ctx,&config);
    //Makesuretofreetheretrievedconfig

ctx

The TileDB context.

config

The config to be retrieved.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_ctx_get_last_error (tiledb_ctx_t *ctx, tiledb_error_t **err) tiledb_ctx_get_last_error tiledb_ctx_t * ctx tiledb_error_t ** err

Retrieves the last TileDB error associated with a TileDB context.

Example:

    tiledb_error_t*error;
    tiledb_ctx_get_last_error(ctx,&error);
    //Makesuretofreetheretrievederror,checkingfirstifitisNULL

ctx

The TileDB context.

err

The last error, or `NULL` if no error has been raised.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_ctx_is_supported_fs (tiledb_ctx_t *ctx, tiledb_filesystem_t fs, int32_t *is_supported) tiledb_ctx_is_supported_fs tiledb_ctx_t * ctx tiledb_filesystem_t fs int32_t * is_supported

Checks if a given storage filesystem backend is supported.

Example:

    int32_tis_supported;
    tiledb_ctx_is_supported_fs(ctx,TILEDB_HDFS,&is_supported);

ctx

The TileDB context.

fs

The filesystem to be checked.

is_supported

Sets it to `1` if the filesystem is supported, and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_ctx_cancel_tasks (tiledb_ctx_t *ctx) tiledb_ctx_cancel_tasks tiledb_ctx_t * ctx

Cancels all background or async tasks associated with the given context.

ctx

The TileDB context.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_ctx_set_tag (tiledb_ctx_t *ctx, const char *key, const char *value) tiledb_ctx_set_tag tiledb_ctx_t * ctx const char * key const char * value

Sets a string key-value "tag" on the given context.

Example:

    tiledb_ctx_set_tag(ctx,"tagkey","tagvalue");

ctx

The TileDB context.

key

The tag key

value

The tag value.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_group_create (tiledb_ctx_t *ctx, const char *group_uri) tiledb_group_create tiledb_ctx_t * ctx const char * group_uri

Creates a new TileDB group.

Example:

    tiledb_group_create(ctx,"my_group");

ctx

The TileDB context.

group_uri

The group URI.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_alloc (tiledb_ctx_t *ctx, tiledb_filter_type_t type, tiledb_filter_t **filter) tiledb_filter_alloc tiledb_ctx_t * ctx tiledb_filter_type_t type tiledb_filter_t ** filter

Creates a TileDB filter.

Example:

    tiledb_filter_t*filter;
    tiledb_filter_alloc(ctx,TILEDB_FILTER_BZIP2,&filter);

ctx

The TileDB context.

type

The filter type.

filter

The TileDB filter to be created.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_filter_free (tiledb_filter_t **filter) tiledb_filter_free tiledb_filter_t ** filter

Destroys a TileDB filter, freeing associated memory.

Example:

    tiledb_filter_t*filter;
    tiledb_filter_alloc(ctx,TILEDB_FILTER_BZIP2,&filter);
    tiledb_filter_free(&filter);

filter

The filter to be destroyed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_get_type (tiledb_ctx_t *ctx, tiledb_filter_t *filter, tiledb_filter_type_t *type) tiledb_filter_get_type tiledb_ctx_t * ctx tiledb_filter_t * filter tiledb_filter_type_t * type

Retrieves the type of a filter.

Example:

    tiledb_filter_t*filter;
    tiledb_filter_alloc(ctx,TILEDB_FILTER_BZIP2,&filter);
    tiledb_filter_type_ttype;
    tiledb_filter_get_type(ctx,filter,&type);
    //type==TILEDB_FILTER_BZIP2

ctx

The TileDB context.

filter

The TileDB filter.

type

The filter type to be retrieved.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_set_option (tiledb_ctx_t *ctx, tiledb_filter_t *filter, tiledb_filter_option_t option, const void *value) tiledb_filter_set_option tiledb_ctx_t * ctx tiledb_filter_t * filter tiledb_filter_option_t option const void * value

Sets an option on a filter. Options are filter dependent; this function returns an error if the given option is not valid for the given filter.

Example:

    tiledb_filter_t*filter;
    tiledb_filter_alloc(ctx,TILEDB_FILTER_BZIP2,&filter);
    int32_tlevel=5;
    tiledb_filter_set_option(ctx,filter,TILEDB_COMPRESSION_LEVEL,&level);
    tiledb_filter_free(&filter);

ctx

TileDB context.

filter

The target filter.

option

Filter option to set.

value

Value of option to set.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_get_option (tiledb_ctx_t *ctx, tiledb_filter_t *filter, tiledb_filter_option_t option, void *value) tiledb_filter_get_option tiledb_ctx_t * ctx tiledb_filter_t * filter tiledb_filter_option_t option void * value

Gets an option value from a filter. Options are filter dependent; this function returns an error if the given option is not valid for the given filter.

Example:

    tiledb_filter_t*filter;
    tiledb_filter_alloc(ctx,TILEDB_FILTER_BZIP2,&filter);
    int32_tlevel;
    tiledb_filter_get_option(ctx,filter,TILEDB_COMPRESSION_LEVEL,&level);
    //level==-1(thedefault)
    tiledb_filter_free(&filter);

The buffer pointed to by `value` must be large enough to hold the option value.

ctx

TileDB context.

filter

The target filter.

option

Filter option to get.

value

Buffer that option value will be written to.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_list_alloc (tiledb_ctx_t *ctx, tiledb_filter_list_t **filter_list) tiledb_filter_list_alloc tiledb_ctx_t * ctx tiledb_filter_list_t ** filter_list

Creates a TileDB filter list (pipeline of filters).

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_filter_list_alloc(ctx,&filter_list);

ctx

The TileDB context.

filter_list

The TileDB filter list to be created.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_filter_list_free (tiledb_filter_list_t **filter_list) tiledb_filter_list_free tiledb_filter_list_t ** filter_list

Destroys a TileDB filter list, freeing associated memory.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_filter_list_alloc(ctx,&filter_list);
    tiledb_filter_list_free(&filter_list);

filter_list

The filter list to be destroyed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_list_add_filter (tiledb_ctx_t *ctx, tiledb_filter_list_t *filter_list, tiledb_filter_t *filter) tiledb_filter_list_add_filter tiledb_ctx_t * ctx tiledb_filter_list_t * filter_list tiledb_filter_t * filter

Appends a filter to a filter list. Data is processed through each filter in the order the filters were added.

Example:

    tiledb_filter_t*filter;
    tiledb_filter_alloc(ctx,TILEDB_FILTER_BZIP2,&filter);

    tiledb_filter_list_t*filter_list;
    tiledb_filter_list_alloc(ctx,&filter_list);
    tiledb_filter_list_add_filter(ctx,filter_list,filter);

    tiledb_filter_list_free(&filter_list);
    tiledb_filter_free(&filter);

ctx

The TileDB context.

filter_list

The target filter list.

filter

The filter to add.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_list_set_max_chunk_size (tiledb_ctx_t *ctx, const tiledb_filter_list_t *filter_list, uint32_t max_chunk_size) tiledb_filter_list_set_max_chunk_size tiledb_ctx_t * ctx const tiledb_filter_list_t * filter_list uint32_t max_chunk_size

Sets the maximum tile chunk size for a filter list.

Example:

    //Setmaxchunksizeto16KB:
    tiledb_filter_list_set_max_chunk_size(ctx,filter_list,16384);

ctx

The TileDB context

filter_list

The target filter list

max_chunk_size

The max chunk size value to set

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_list_get_nfilters (tiledb_ctx_t *ctx, const tiledb_filter_list_t *filter_list, uint32_t *nfilters) tiledb_filter_list_get_nfilters tiledb_ctx_t * ctx const tiledb_filter_list_t * filter_list uint32_t * nfilters

Retrieves the number of filters in a filter list.

Example:

    uint32_tnum_filters;
    tiledb_filter_list_get_nfilters(ctx,filter_list,&num_filters);

ctx

The TileDB context

filter_list

The filter list

nfilters

The number of filters on the filter list

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_list_get_filter_from_index (tiledb_ctx_t *ctx, const tiledb_filter_list_t *filter_list, uint32_t index, tiledb_filter_t **filter) tiledb_filter_list_get_filter_from_index tiledb_ctx_t * ctx const tiledb_filter_list_t * filter_list uint32_t index tiledb_filter_t ** filter

Retrieves a filter object from a filter list by index.

Example:

The following retrieves the first filter from a filter list.

    tiledb_filter_t*filter;
    tiledb_filter_list_get_filter_from_index(ctx,filter_list,0,&filter);
    tiledb_filter_free(&filter);

ctx

The TileDB context

filter_list

The filter list to retrieve the filter from

index

The index of the filter

filter

The retrieved filter object.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_filter_list_get_max_chunk_size (tiledb_ctx_t *ctx, const tiledb_filter_list_t *filter_list, uint32_t *max_chunk_size) tiledb_filter_list_get_max_chunk_size tiledb_ctx_t * ctx const tiledb_filter_list_t * filter_list uint32_t * max_chunk_size

Gets the maximum tile chunk size for a filter list.

Example:

    uint32_tmax_chunk_size;
    tiledb_filter_list_get_max_chunk_size(ctx,filter_list,&max_chunk_size);

ctx

The TileDB context

filter_list

The target filter list

max_chunk_size

The retrieved max chunk size value

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_alloc (tiledb_ctx_t *ctx, const char *name, tiledb_datatype_t type, tiledb_attribute_t **attr) tiledb_attribute_alloc tiledb_ctx_t * ctx const char * name tiledb_datatype_t type tiledb_attribute_t ** attr

Creates a TileDB attribute.

Example:

    tiledb_attribute_t*attr;
    tiledb_attribute_alloc(ctx,"my_attr",TILEDB_INT32,&attr);

ctx

The TileDB context.

name

The attribute name. Providing an empty string for the name creates an anonymous attribute.

type

The attribute type.

attr

The TileDB attribute to be created.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

The default number of values per cell is 1.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_attribute_free (tiledb_attribute_t **attr) tiledb_attribute_free tiledb_attribute_t ** attr

Destroys a TileDB attribute, freeing associated memory.

Example:

    tiledb_attribute_t*attr;
    tiledb_attribute_alloc(ctx,"my_attr",TILEDB_INT32,&attr);
    tiledb_attribute_free(&attr);

attr

The attribute to be destroyed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_set_nullable (tiledb_ctx_t *ctx, tiledb_attribute_t *attr, uint8_t nullable) tiledb_attribute_set_nullable tiledb_ctx_t * ctx tiledb_attribute_t * attr uint8_t nullable

Sets the nullability of an attribute.

Example:

    tiledb_attribute_set_nullable(ctx,attr,1);

ctx

The TileDB context.

attr

The target attribute.

nullable

Non-zero if the attribute is nullable.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_set_filter_list (tiledb_ctx_t *ctx, tiledb_attribute_t *attr, tiledb_filter_list_t *filter_list) tiledb_attribute_set_filter_list tiledb_ctx_t * ctx tiledb_attribute_t * attr tiledb_filter_list_t * filter_list

Sets the filter list for an attribute.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_filter_list_alloc(ctx,&filter_list);
    tiledb_filter_list_add_filter(ctx,filter_list,filter);
    tiledb_attribute_set_filter_list(ctx,attr,filter_list);

ctx

The TileDB context.

attr

The target attribute.

filter_list

The filter_list to be set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_set_cell_val_num (tiledb_ctx_t *ctx, tiledb_attribute_t *attr, uint32_t cell_val_num) tiledb_attribute_set_cell_val_num tiledb_ctx_t * ctx tiledb_attribute_t * attr uint32_t cell_val_num

Sets the number of values per cell for an attribute. If this is not used, the default is `1`.

Examples:

For a fixed-sized attribute:

    tiledb_attribute_set_cell_val_num(ctx,attr,3);

For a variable-sized attribute:

    tiledb_attribute_set_cell_val_num(ctx,attr,TILEDB_VAR_NUM);

ctx

The TileDB context.

attr

The target attribute.

cell_val_num

The number of values per cell.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_get_name (tiledb_ctx_t *ctx, const tiledb_attribute_t *attr, const char **name) tiledb_attribute_get_name tiledb_ctx_t * ctx const tiledb_attribute_t * attr const char ** name

Retrieves the attribute name.

Example:

    constchar*attr_name;
    tiledb_attribute_get_name(ctx,attr,&attr_name);

ctx

The TileDB context.

attr

The attribute.

name

The name to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_get_type (tiledb_ctx_t *ctx, const tiledb_attribute_t *attr, tiledb_datatype_t *type) tiledb_attribute_get_type tiledb_ctx_t * ctx const tiledb_attribute_t * attr tiledb_datatype_t * type

Retrieves the attribute type.

Example:

    tiledb_datatype_tattr_type;
    tiledb_attribute_get_type(ctx,attr,&attr_type);

ctx

The TileDB context.

attr

The attribute.

type

The type to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_get_nullable (tiledb_ctx_t *ctx, tiledb_attribute_t *attr, uint8_t *nullable) tiledb_attribute_get_nullable tiledb_ctx_t * ctx tiledb_attribute_t * attr uint8_t * nullable

Sets the nullability of an attribute.

Example:

    uint8_tnullable;
    tiledb_attribute_get_nullable(ctx,attr,&nullable);

ctx

The TileDB context.

attr

The target attribute.

nullable

Output argument, non-zero for nullable and zero for non-nullable.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_get_filter_list (tiledb_ctx_t *ctx, tiledb_attribute_t *attr, tiledb_filter_list_t **filter_list) tiledb_attribute_get_filter_list tiledb_ctx_t * ctx tiledb_attribute_t * attr tiledb_filter_list_t ** filter_list

Retrieves the filter list for an attribute.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_attribute_get_filter_list(ctx,attr,&filter_list);
    tiledb_filter_list_free(&filter_list);

ctx

The TileDB context.

attr

The target attribute.

filter_list

The filter list to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_get_cell_val_num (tiledb_ctx_t *ctx, const tiledb_attribute_t *attr, uint32_t *cell_val_num) tiledb_attribute_get_cell_val_num tiledb_ctx_t * ctx const tiledb_attribute_t * attr uint32_t * cell_val_num

Retrieves the number of values per cell for the attribute. For variable-sized attributes result is TILEDB_VAR_NUM.

Example:

    uint32_tnum;
    tiledb_attribute_get_cell_val_num(ctx,attr,&num);

ctx

The TileDB context.

attr

The attribute.

cell_val_num

The number of values per cell to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_get_cell_size (tiledb_ctx_t *ctx, const tiledb_attribute_t *attr, uint64_t *cell_size) tiledb_attribute_get_cell_size tiledb_ctx_t * ctx const tiledb_attribute_t * attr uint64_t * cell_size

Retrieves the cell size for this attribute.

Example:

    uint64_tcell_size;
    tiledb_attribute_get_cell_size(ctx,attr,&cell_size);

ctx

The TileDB context.

attr

The attribute.

cell_size

The cell size to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_dump (tiledb_ctx_t *ctx, const tiledb_attribute_t *attr, FILE *out) tiledb_attribute_dump tiledb_ctx_t * ctx const tiledb_attribute_t * attr FILE * out

Dumps the contents of an attribute in ASCII form to some output (e.g., file or stdout).

Example:

The following prints the attribute dump to standard output.

    tiledb_attribute_dump(ctx,attr,stdout);

ctx

The TileDB context.

attr

The attribute.

out

The output.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_set_fill_value (tiledb_ctx_t *ctx, tiledb_attribute_t *attr, const void *value, uint64_t size) tiledb_attribute_set_fill_value tiledb_ctx_t * ctx tiledb_attribute_t * attr const void * value uint64_t size

Sets the default fill value for the input attribute. This value will be used for the input attribute whenever querying (1) an empty cell in a dense array, or (2) a non-empty cell (in either dense or sparse array) when values on the input attribute are missing (e.g., if the user writes a subset of the attributes in a write operation).

Applicable to var-sized attributes.

Example:

    //Assummingaint32attribute
    int32_tvalue=0;
    uint64_tsize=sizeof(value);
    tiledb_attribute_set_fill_value(ctx,attr,&value,size);

    //Assummingavarcharattribute
    constchar*value="foo";
    uint64_tsize=strlen(value);
    tiledb_attribute_set_fill_value(ctx,attr,value,size);

ctx

The TileDB context.

attr

The target attribute.

value

The fill value to set.

size

The fill value size in bytes.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

A call to `tiledb_attribute_cell_val_num` sets the fill value of the attribute to its default. Therefore, make sure you invoke `tiledb_attribute_set_fill_value` after deciding on the number of values this attribute will hold in each cell.

For fixed-sized attributes, the input `size` should be equal to the cell size.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_get_fill_value (tiledb_ctx_t *ctx, tiledb_attribute_t *attr, const void **value, uint64_t *size) tiledb_attribute_get_fill_value tiledb_ctx_t * ctx tiledb_attribute_t * attr const void ** value uint64_t * size

Gets the default fill value for the input attribute. This value will be used for the input attribute whenever querying (1) an empty cell in a dense array, or (2) a non-empty cell (in either dense or sparse array) when values on the input attribute are missing (e.g., if the user writes a subset of the attributes in a write operation).

Applicable to both fixed-sized and var-sized attributes.

Example:

    //Assumingaint32attribute
    constint32_t*value;
    uint64_tsize;
    tiledb_attribute_get_fill_value(ctx,attr,&value,&size);

    //Assumingavarcharattribute
    constchar*value;
    uint64_tsize;
    tiledb_attribute_get_fill_value(ctx,attr,&value,&size);

ctx

The TileDB context.

attr

The target attribute.

value

A pointer to the fill value to get.

size

The size of the fill value to get.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_set_fill_value_nullable (tiledb_ctx_t *ctx, tiledb_attribute_t *attr, const void *value, uint64_t size, uint8_t validity) tiledb_attribute_set_fill_value_nullable tiledb_ctx_t * ctx tiledb_attribute_t * attr const void * value uint64_t size uint8_t validity

Sets the default fill value for the input, nullable attribute. This value will be used for the input attribute whenever querying (1) an empty cell in a dense array, or (2) a non-empty cell (in either dense or sparse array) when values on the input attribute are missing (e.g., if the user writes a subset of the attributes in a write operation).

Applicable to var-sized attributes.

Example:

    //Assummingaint32attribute
    int32_tvalue=0;
    uint64_tsize=sizeof(value);
    uint8_tvalid=0;
    tiledb_attribute_set_fill_value_nullable(ctx,attr,&value,size,valid);

    //Assummingavarcharattribute
    constchar*value="foo";
    uint64_tsize=strlen(value);
    uint8_tvalid=1;
    tiledb_attribute_set_fill_value_nullable(ctx,attr,value,size,valid);

ctx

The TileDB context.

attr

The target attribute.

value

The fill value to set.

size

The fill value size in bytes.

validity

The validity fill value, zero for a null value and non-zero for a valid attribute.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

A call to `tiledb_attribute_cell_val_num` sets the fill value of the attribute to its default. Therefore, make sure you invoke `tiledb_attribute_set_fill_value_nullable` after deciding on the number of values this attribute will hold in each cell.

For fixed-sized attributes, the input `size` should be equal to the cell size.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_attribute_get_fill_value_nullable (tiledb_ctx_t *ctx, tiledb_attribute_t *attr, const void **value, uint64_t *size, uint8_t *valid) tiledb_attribute_get_fill_value_nullable tiledb_ctx_t * ctx tiledb_attribute_t * attr const void ** value uint64_t * size uint8_t * valid

Gets the default fill value for the input, nullable attribute. This value will be used for the input attribute whenever querying (1) an empty cell in a dense array, or (2) a non-empty cell (in either dense or sparse array) when values on the input attribute are missing (e.g., if the user writes a subset of the attributes in a write operation).

Applicable to both fixed-sized and var-sized attributes.

Example:

    //Assumingaint32attribute
    constint32_t*value;
    uint64_tsize;
    uint8_tvalid;
    tiledb_attribute_get_fill_value_nullable(ctx,attr,&value,&size,&valid);

    //Assumingavarcharattribute
    constchar*value;
    uint64_tsize;
    uint8_tvalid;
    tiledb_attribute_get_fill_value_nullable(ctx,attr,&value,&size,&valid);

ctx

The TileDB context.

attr

The target attribute.

value

A pointer to the fill value to get.

size

The size of the fill value to get.

valid

The fill value validity to get.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_domain_alloc (tiledb_ctx_t *ctx, tiledb_domain_t **domain) tiledb_domain_alloc tiledb_ctx_t * ctx tiledb_domain_t ** domain

Creates a TileDB domain.

Example:

    tiledb_domain_t*domain;
    tiledb_domain_alloc(ctx,&domain);

ctx

The TileDB context.

domain

The TileDB domain to be created.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_domain_free (tiledb_domain_t **domain) tiledb_domain_free tiledb_domain_t ** domain

Destroys a TileDB domain, freeing associated memory.

Example:

    tiledb_domain_t*domain;
    tiledb_domain_alloc(ctx,&domain);
    tiledb_domain_free(&domain);

domain

The domain to be destroyed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_domain_get_type (tiledb_ctx_t *ctx, const tiledb_domain_t *domain, tiledb_datatype_t *type) tiledb_domain_get_type tiledb_ctx_t * ctx const tiledb_domain_t * domain tiledb_datatype_t * type

Retrieves the domain's type.

Example:

    tiledb_datatype_ttype;
    tiledb_domain_get_type(ctx,domain,&type);

ctx

The TileDB context.

domain

The domain.

type

The type to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_domain_get_ndim (tiledb_ctx_t *ctx, const tiledb_domain_t *domain, uint32_t *ndim) tiledb_domain_get_ndim tiledb_ctx_t * ctx const tiledb_domain_t * domain uint32_t * ndim

Retrieves the number of dimensions in a domain.

Example:

    uint32_tdim_num;
    tiledb_domain_get_ndim(ctx,domain,&dim_num);

ctx

The TileDB context

domain

The domain

ndim

The number of dimensions in a domain.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_domain_add_dimension (tiledb_ctx_t *ctx, tiledb_domain_t *domain, tiledb_dimension_t *dim) tiledb_domain_add_dimension tiledb_ctx_t * ctx tiledb_domain_t * domain tiledb_dimension_t * dim

Adds a dimension to a TileDB domain.

Example:

    tiledb_dimension_t*dim;
    int64_tdim_domain[]={1,10};
    int64_ttile_extent=5;
    tiledb_dimension_alloc(
    ctx,"dim_0",TILEDB_INT64,dim_domain,&tile_extent,&dim);
    tiledb_domain_add_dimension(ctx,domain,dim);

ctx

The TileDB context.

domain

The domain to add the dimension to.

dim

The dimension to be added.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_domain_get_dimension_from_index (tiledb_ctx_t *ctx, const tiledb_domain_t *domain, uint32_t index, tiledb_dimension_t **dim) tiledb_domain_get_dimension_from_index tiledb_ctx_t * ctx const tiledb_domain_t * domain uint32_t index tiledb_dimension_t ** dim

Retrieves a dimension object from a domain by index.

Example:

The following retrieves the first dimension from a domain.

    tiledb_dimension_t*dim;
    tiledb_domain_get_dimension_from_index(ctx,domain,0,&dim);

ctx

The TileDB context

domain

The domain to add the dimension to.

index

The index of domain dimension

dim

The retrieved dimension object.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_domain_get_dimension_from_name (tiledb_ctx_t *ctx, const tiledb_domain_t *domain, const char *name, tiledb_dimension_t **dim) tiledb_domain_get_dimension_from_name tiledb_ctx_t * ctx const tiledb_domain_t * domain const char * name tiledb_dimension_t ** dim

Retrieves a dimension object from a domain by name (key).

Example:

    tiledb_dimension_t*dim;
    tiledb_domain_get_dimension_from_name(ctx,domain,"dim_0",&dim);

ctx

The TileDB context

domain

The domain to add the dimension to.

name

The name (key) of the requested dimension

dim

The retrieved dimension object.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_domain_has_dimension (tiledb_ctx_t *ctx, const tiledb_domain_t *domain, const char *name, int32_t *has_dim) tiledb_domain_has_dimension tiledb_ctx_t * ctx const tiledb_domain_t * domain const char * name int32_t * has_dim

Checks whether the domain has a dimension of the given name.

Example:

    int32_thas_dim;
    tiledb_domain_has_dimension(ctx,domain,"dim_0",&has_dim);

ctx

The TileDB context.

domain

The domain.

name

The name of the dimension to check for.

has_dim

Set to `1` if the domain has a dimension of the given name, else `0`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_domain_dump (tiledb_ctx_t *ctx, const tiledb_domain_t *domain, FILE *out) tiledb_domain_dump tiledb_ctx_t * ctx const tiledb_domain_t * domain FILE * out

Dumps the info of a domain in ASCII form to some output (e.g., file or `stdout`).

Example:

The following prints the domain dump to the standard output.

    tiledb_domain_dump(ctx,domain,stdout);

ctx

The TileDB context.

domain

The domain.

out

The output.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_dimension_alloc (tiledb_ctx_t *ctx, const char *name, tiledb_datatype_t type, const void *dim_domain, const void *tile_extent, tiledb_dimension_t **dim) tiledb_dimension_alloc tiledb_ctx_t * ctx const char * name tiledb_datatype_t type const void * dim_domain const void * tile_extent tiledb_dimension_t ** dim

Creates a dimension.

Example:

    tiledb_dimension_t*dim;
    int64_tdim_domain[]={1,10};
    int64_ttile_extent=5;
    tiledb_dimension_alloc(
    ctx,"dim_0",TILEDB_INT64,dim_domain,&tile_extent,&dim);

ctx

The TileDB context.

name

The dimension name.

type

The dimension type.

dim_domain

The dimension domain.

tile_extent

The dimension tile extent.

dim

The dimension to be created.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_dimension_free (tiledb_dimension_t **dim) tiledb_dimension_free tiledb_dimension_t ** dim

Destroys a TileDB dimension, freeing associated memory.

Example:

    tiledb_dimension_free(&dim);

dim

The dimension to be destroyed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_dimension_set_filter_list (tiledb_ctx_t *ctx, tiledb_dimension_t *dim, tiledb_filter_list_t *filter_list) tiledb_dimension_set_filter_list tiledb_ctx_t * ctx tiledb_dimension_t * dim tiledb_filter_list_t * filter_list

Sets the filter list for a dimension.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_filter_list_alloc(ctx,&filter_list);
    tiledb_filter_list_add_filter(ctx,filter_list,filter);
    tiledb_dimension_set_filter_list(ctx,dim,filter_list);

ctx

The TileDB context.

dim

The target dimension.

filter_list

The filter_list to be set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_dimension_set_cell_val_num (tiledb_ctx_t *ctx, tiledb_dimension_t *dim, uint32_t cell_val_num) tiledb_dimension_set_cell_val_num tiledb_ctx_t * ctx tiledb_dimension_t * dim uint32_t cell_val_num

Sets the number of values per cell for a dimension. If this is not used, the default is `1`.

Examples:

For a fixed-sized dimension:

    tiledb_dimension_set_cell_val_num(ctx,dim,3);

For a variable-sized dimension:

    tiledb_dimension_set_cell_val_num(ctx,dim,TILEDB_VAR_NUM);

ctx

The TileDB context.

dim

The target dimension.

cell_val_num

The number of values per cell.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_dimension_get_filter_list (tiledb_ctx_t *ctx, tiledb_dimension_t *dim, tiledb_filter_list_t **filter_list) tiledb_dimension_get_filter_list tiledb_ctx_t * ctx tiledb_dimension_t * dim tiledb_filter_list_t ** filter_list

Retrieves the filter list for a dimension.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_dimension_get_filter_list(ctx,dim,&filter_list);
    tiledb_filter_list_free(&filter_list);

ctx

The TileDB context.

dim

The target dimension.

filter_list

The filter list to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_dimension_get_cell_val_num (tiledb_ctx_t *ctx, const tiledb_dimension_t *dim, uint32_t *cell_val_num) tiledb_dimension_get_cell_val_num tiledb_ctx_t * ctx const tiledb_dimension_t * dim uint32_t * cell_val_num

Retrieves the number of values per cell for a dimension. For variable-sized dimensions the result is TILEDB_VAR_NUM.

Example:

    uint32_tnum;
    tiledb_dimension_get_cell_val_num(ctx,dim,&num);

ctx

The TileDB context.

dim

The dimension.

cell_val_num

The number of values per cell to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_dimension_get_name (tiledb_ctx_t *ctx, const tiledb_dimension_t *dim, const char **name) tiledb_dimension_get_name tiledb_ctx_t * ctx const tiledb_dimension_t * dim const char ** name

Retrieves the dimension name.

Example:

    constchar*dim_name;
    tiledb_dimension_get_name(ctx,dim,&dim_name);

ctx

The TileDB context.

dim

The dimension.

name

The name to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_dimension_get_type (tiledb_ctx_t *ctx, const tiledb_dimension_t *dim, tiledb_datatype_t *type) tiledb_dimension_get_type tiledb_ctx_t * ctx const tiledb_dimension_t * dim tiledb_datatype_t * type

Retrieves the dimension type.

Example:

    tiledb_datatype_tdim_type;
    tiledb_dimension_get_type(ctx,dim,&dim_type);

ctx

The TileDB context.

dim

The dimension.

type

The type to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_dimension_get_domain (tiledb_ctx_t *ctx, const tiledb_dimension_t *dim, const void **domain) tiledb_dimension_get_domain tiledb_ctx_t * ctx const tiledb_dimension_t * dim const void ** domain

Retrieves the domain of the dimension.

Example:

    uint64_t*domain;
    tiledb_dimension_get_domain(ctx,dim,&domain);

ctx

The TileDB context.

dim

The dimension.

domain

The domain to be retrieved. Note that the defined type of input `domain` must be the same as the dimension type, otherwise the behavior is unpredictable (it will probably segfault).

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_dimension_get_tile_extent (tiledb_ctx_t *ctx, const tiledb_dimension_t *dim, const void **tile_extent) tiledb_dimension_get_tile_extent tiledb_ctx_t * ctx const tiledb_dimension_t * dim const void ** tile_extent

Retrieves the tile extent of the dimension.

Example:

    uint64_t*tile_extent;
    tiledb_dimension_get_tile_extent(ctx,dim,&tile_extent);

ctx

The TileDB context.

dim

The dimension.

tile_extent

The tile extent (pointer) to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_dimension_dump (tiledb_ctx_t *ctx, const tiledb_dimension_t *dim, FILE *out) tiledb_dimension_dump tiledb_ctx_t * ctx const tiledb_dimension_t * dim FILE * out

Dumps the contents of a dimension in ASCII form to some output (e.g., file or stdout).

Example:

The following prints the dimension dump to standard output.

    tiledb_dimension_dump(ctx,dim,stdout);

ctx

The TileDB context.

dim

The dimension.

out

The output.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_alloc (tiledb_ctx_t *ctx, tiledb_array_type_t array_type, tiledb_array_schema_t **array_schema) tiledb_array_schema_alloc tiledb_ctx_t * ctx tiledb_array_type_t array_type tiledb_array_schema_t ** array_schema

Creates a TileDB array schema object.

Example:

    tiledb_array_schema_t*array_schema;
    tiledb_array_schema_alloc(ctx,TILEDB_DENSE,&array_schema);

ctx

The TileDB context.

array_type

The array type.

array_schema

The TileDB array schema to be created.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_array_schema_free (tiledb_array_schema_t **array_schema) tiledb_array_schema_free tiledb_array_schema_t ** array_schema

Destroys an array schema, freeing associated memory.

Example:

    tiledb_array_schema_free(&array_schema);

array_schema

The array schema to be destroyed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_add_attribute (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, tiledb_attribute_t *attr) tiledb_array_schema_add_attribute tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema tiledb_attribute_t * attr

Adds an attribute to an array schema.

Example:

    tiledb_attribute_t*attr;
    tiledb_attribute_alloc(ctx,"my_attr",TILEDB_INT32,&attr);
    tiledb_array_schema_add_attribute(ctx,array_schema,attr);

ctx

The TileDB context.

array_schema

The array schema.

attr

The attribute to be added.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_set_allows_dups (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, int allows_dups) tiledb_array_schema_set_allows_dups tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema int allows_dups

Sets whether the array can allow coordinate duplicates or not. Applicable only to sparse arrays (it errors out if set to `1` for dense arrays).

Example:

    intallows_dups=1;
    tiledb_array_schema_set_allows_dups(ctx,array_schema,allows_dups);

ctx

The TileDB context.

array_schema

The array schema.

allows_dups

Whether or not the array allows coordinate duplicates.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_allows_dups (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, int *allows_dups) tiledb_array_schema_get_allows_dups tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema int * allows_dups

Gets whether the array can allow coordinate duplicates or not. It should always be `0` for dense arrays.

Example:

    intallows_dups;
    tiledb_array_schema_get_allows_dups(ctx,array_schema,&allows_dups);

ctx

The TileDB context.

array_schema

The array schema.

allows_dups

Whether or not the array allows coordinate duplicates.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_set_domain (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, tiledb_domain_t *domain) tiledb_array_schema_set_domain tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema tiledb_domain_t * domain

Sets a domain for the array schema.

Example:

    tiledb_domain_t*domain;
    tiledb_domain_alloc(ctx,&domain);
    //--Adddimensionstothedomainhere--//
    tiledb_array_schema_set_domain(ctx,array_schema,domain);

ctx

The TileDB context.

array_schema

The array schema.

domain

The domain to be set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_set_capacity (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, uint64_t capacity) tiledb_array_schema_set_capacity tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema uint64_t capacity

Sets the tile capacity.

Example:

    tiledb_array_schema_set_capacity(ctx,array_schema,10000);

ctx

The TileDB context.

array_schema

The array schema.

capacity

The capacity of a sparse data tile. Note that sparse data tiles exist in sparse fragments, which can be created in both sparse and dense arrays. For more details, see tutorials/tiling-sparse.html.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_set_cell_order (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, tiledb_layout_t cell_order) tiledb_array_schema_set_cell_order tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema tiledb_layout_t cell_order

Sets the cell order.

Example:

    tiledb_array_schema_set_cell_order(ctx,array_schema,TILEDB_ROW_MAJOR);

ctx

The TileDB context.

array_schema

The array schema.

cell_order

The cell order to be set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_set_tile_order (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, tiledb_layout_t tile_order) tiledb_array_schema_set_tile_order tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema tiledb_layout_t tile_order

Sets the tile order.

Example:

    tiledb_array_schema_set_cell_order(ctx,array_schema,TILEDB_COL_MAJOR);

ctx

The TileDB context.

array_schema

The array schema.

tile_order

The tile order to be set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_set_coords_filter_list (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, tiledb_filter_list_t *filter_list) tiledb_array_schema_set_coords_filter_list tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema tiledb_filter_list_t * filter_list

Sets the filter list to use for the coordinates.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_filter_list_alloc(ctx,&filter_list);
    tiledb_filter_list_add_filter(ctx,filter_list,filter);
    tiledb_array_schema_set_coords_filter_list(ctx,array_schema,filter_list);

ctx

The TileDB context.

array_schema

The array schema.

filter_list

The filter list to be set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_set_offsets_filter_list (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, tiledb_filter_list_t *filter_list) tiledb_array_schema_set_offsets_filter_list tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema tiledb_filter_list_t * filter_list

Sets the filter list to use for the offsets of variable-sized attribute values.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_filter_list_alloc(ctx,&filter_list);
    tiledb_filter_list_add_filter(ctx,filter_list,filter);
    tiledb_array_schema_set_offsets_filter_list(ctx,array_schema,filter_list);

ctx

The TileDB context.

array_schema

The array schema.

filter_list

The filter list to be set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_set_validity_filter_list (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, tiledb_filter_list_t *filter_list) tiledb_array_schema_set_validity_filter_list tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema tiledb_filter_list_t * filter_list

Sets the filter list to use for the validity array of nullable attribute values.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_filter_list_alloc(ctx,&filter_list);
    tiledb_filter_list_add_filter(ctx,filter_list,filter);
    tiledb_array_schema_set_validity_filter_list(ctx,array_schema,filter_list);

ctx

The TileDB context.

array_schema

The array schema.

filter_list

The filter list to be set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_check (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema) tiledb_array_schema_check tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema

Checks the correctness of the array schema.

Example:

    tiledb_array_schema_check(ctx,array_schema);

ctx

The TileDB context.

array_schema

The array schema.

`TILEDB_OK` if the array schema is correct and `TILEDB_ERR` upon any error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_load (tiledb_ctx_t *ctx, const char *array_uri, tiledb_array_schema_t **array_schema) tiledb_array_schema_load tiledb_ctx_t * ctx const char * array_uri tiledb_array_schema_t ** array_schema

Retrieves the schema of an array from the disk, creating an array schema struct.

Example:

    tiledb_array_schema_t*array_schema;
    tiledb_array_schema_load(ctx,"s3://tiledb_bucket/my_array",&array_schema);
    //Makesuretofreethearrayschemaintheend

ctx

The TileDB context.

array_uri

The array whose schema will be retrieved.

array_schema

The array schema to be retrieved, or `NULL` upon error.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_array_schema_load_with_key (tiledb_ctx_t *ctx, const char *array_uri, tiledb_encryption_type_t encryption_type, const void *encryption_key, uint32_t key_length, tiledb_array_schema_t **array_schema) tiledb_array_schema_load_with_key tiledb_ctx_t * ctx const char * array_uri tiledb_encryption_type_t encryption_type const void * encryption_key uint32_t key_length tiledb_array_schema_t ** array_schema

Retrieves the schema of an encrypted array from the disk, creating an array schema struct.

Example:

    //LoadAES-256keyfromdisk,environmentvariable,etc.
    uint8_tkey[32]=...;
    tiledb_array_schema_t*array_schema;
    tiledb_array_schema_load_with_key(
    ctx,"s3://tiledb_bucket/my_array",TILEDB_AES_256_GCM,
    key,sizeof(key),&array_schema);
    //Makesuretofreethearrayschemaintheend

ctx

The TileDB context.

array_uri

The array whose schema will be retrieved.

encryption_type

The encryption type to use.

encryption_key

The encryption key to use.

key_length

Length in bytes of the encryption key.

array_schema

The array schema to be retrieved, or `NULL` upon error.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_array_type (tiledb_ctx_t *ctx, const tiledb_array_schema_t *array_schema, tiledb_array_type_t *array_type) tiledb_array_schema_get_array_type tiledb_ctx_t * ctx const tiledb_array_schema_t * array_schema tiledb_array_type_t * array_type

Retrieves the array type.

Example:

    tiledb_array_schema_t*array_schema;
    tiledb_array_schema_load(ctx,"s3://tiledb_bucket/my_array",array_schema);
    tiledb_array_type_t*array_type;
    tiledb_array_schema_get_array_type(ctx,array_schema,&array_type);
    //Makesuretofreethearrayschemaintheend

ctx

The TileDB context.

array_schema

The array schema.

array_type

The array type to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_capacity (tiledb_ctx_t *ctx, const tiledb_array_schema_t *array_schema, uint64_t *capacity) tiledb_array_schema_get_capacity tiledb_ctx_t * ctx const tiledb_array_schema_t * array_schema uint64_t * capacity

Retrieves the capacity.

Example:

    uint64_tcapacity;
    tiledb_array_schema_get_capacity(ctx,array_schema,&capacity);

ctx

The TileDB context.

array_schema

The array schema.

capacity

The capacity to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_cell_order (tiledb_ctx_t *ctx, const tiledb_array_schema_t *array_schema, tiledb_layout_t *cell_order) tiledb_array_schema_get_cell_order tiledb_ctx_t * ctx const tiledb_array_schema_t * array_schema tiledb_layout_t * cell_order

Retrieves the cell order.

Example:

    tiledb_layout_tcell_order;
    tiledb_array_schema_get_cell_order(ctx,array_schema,&cell_order);

ctx

The TileDB context.

array_schema

The array schema.

cell_order

The cell order to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_coords_filter_list (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, tiledb_filter_list_t **filter_list) tiledb_array_schema_get_coords_filter_list tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema tiledb_filter_list_t ** filter_list

Retrieves the filter list used for the coordinates.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_array_schema_get_coords_filter_list(ctx,array_schema,&filter_list);
    tiledb_filter_list_free(ctx,&filter_list);

ctx

The TileDB context.

array_schema

The array schema.

filter_list

The filter list to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_offsets_filter_list (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, tiledb_filter_list_t **filter_list) tiledb_array_schema_get_offsets_filter_list tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema tiledb_filter_list_t ** filter_list

Retrieves the filter list used for the offsets.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_array_schema_get_offsets_filter_list(ctx,array_schema,&filter_list);
    tiledb_filter_list_free(ctx,&filter_list);

ctx

The TileDB context.

array_schema

The array schema.

filter_list

The filter list to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_validity_filter_list (tiledb_ctx_t *ctx, tiledb_array_schema_t *array_schema, tiledb_filter_list_t **filter_list) tiledb_array_schema_get_validity_filter_list tiledb_ctx_t * ctx tiledb_array_schema_t * array_schema tiledb_filter_list_t ** filter_list

Retrieves the filter list used for validity maps.

Example:

    tiledb_filter_list_t*filter_list;
    tiledb_array_schema_get_validity_filter_list(ctx,array_schema,
    &filter_list);tiledb_filter_list_free(ctx,&filter_list);

ctx

The TileDB context.

array_schema

The array schema.

filter_list

The filter list to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_domain (tiledb_ctx_t *ctx, const tiledb_array_schema_t *array_schema, tiledb_domain_t **domain) tiledb_array_schema_get_domain tiledb_ctx_t * ctx const tiledb_array_schema_t * array_schema tiledb_domain_t ** domain

Retrieves the array domain.

Example:

    tiledb_domain_t*domain;
    tiledb_array_schema_get_domain(ctx,array_schema,&domain);
    //Makesuretodeletedomainintheend

ctx

The TileDB context.

array_schema

The array schema.

domain

The array domain to be retrieved.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_tile_order (tiledb_ctx_t *ctx, const tiledb_array_schema_t *array_schema, tiledb_layout_t *tile_order) tiledb_array_schema_get_tile_order tiledb_ctx_t * ctx const tiledb_array_schema_t * array_schema tiledb_layout_t * tile_order

Retrieves the tile order.

Example:

    tiledb_layout_ttile_order;
    tiledb_array_schema_get_tile_order(ctx,array_schema,&tile_order);

ctx

The TileDB context.

array_schema

The array schema.

tile_order

The tile order to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_attribute_num (tiledb_ctx_t *ctx, const tiledb_array_schema_t *array_schema, uint32_t *attribute_num) tiledb_array_schema_get_attribute_num tiledb_ctx_t * ctx const tiledb_array_schema_t * array_schema uint32_t * attribute_num

Retrieves the number of array attributes.

Example:

    uint32_tattr_num;
    tiledb_array_schema_get_attribute_num(ctx,array_schema,&attr_num);

ctx

The TileDB context.

array_schema

The array schema.

attribute_num

The number of attributes to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_attribute_from_index (tiledb_ctx_t *ctx, const tiledb_array_schema_t *array_schema, uint32_t index, tiledb_attribute_t **attr) tiledb_array_schema_get_attribute_from_index tiledb_ctx_t * ctx const tiledb_array_schema_t * array_schema uint32_t index tiledb_attribute_t ** attr

Retrieves an attribute given its index.

Attributes are ordered the same way they were defined when constructing the array schema.

Example:

The following retrieves the first attribute in the schema.

    tiledb_attribute_t*attr;
    tiledb_array_schema_get_attribute_from_index(ctx,array_schema,0,&attr);
    //Makesuretodeletetheretrievedattributeintheend.

ctx

The TileDB context.

array_schema

The array schema.

index

The index of the attribute to retrieve.

attr

The attribute object to retrieve.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_get_attribute_from_name (tiledb_ctx_t *ctx, const tiledb_array_schema_t *array_schema, const char *name, tiledb_attribute_t **attr) tiledb_array_schema_get_attribute_from_name tiledb_ctx_t * ctx const tiledb_array_schema_t * array_schema const char * name tiledb_attribute_t ** attr

Retrieves an attribute given its name (key).

Example:

The following retrieves the first attribute in the schema.

    tiledb_attribute_t*attr;
    tiledb_array_schema_get_attribute_from_name(
    ctx,array_schema,"attr_0",&attr);
    //Makesuretodeletetheretrievedattributeintheend.

ctx

The TileDB context.

array_schema

The array schema.

name

The name (key) of the attribute to retrieve.

attr

THe attribute object to retrieve.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_has_attribute (tiledb_ctx_t *ctx, const tiledb_array_schema_t *array_schema, const char *name, int32_t *has_attr) tiledb_array_schema_has_attribute tiledb_ctx_t * ctx const tiledb_array_schema_t * array_schema const char * name int32_t * has_attr

Checks whether the array schema has an attribute of the given name.

Example:

    int32_thas_attr;
    tiledb_array_schema_has_attribute(ctx,array_schema,"attr_0",&has_attr);

ctx

The TileDB context.

array_schema

The array schema.

name

The name of the attribute to check for.

has_attr

Set to `1` if the array schema has an attribute of the given name, else `0`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_schema_dump (tiledb_ctx_t *ctx, const tiledb_array_schema_t *array_schema, FILE *out) tiledb_array_schema_dump tiledb_ctx_t * ctx const tiledb_array_schema_t * array_schema FILE * out

Dumps the array schema in ASCII format in the selected output.

Example:

The following prints the array schema dump in standard output.

    tiledb_array_schema_dump(ctx,array_schema,stdout);

ctx

The TileDB context.

array_schema

The array schema.

out

The output.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_alloc (tiledb_ctx_t *ctx, tiledb_array_t *array, tiledb_query_type_t query_type, tiledb_query_t **query) tiledb_query_alloc tiledb_ctx_t * ctx tiledb_array_t * array tiledb_query_type_t query_type tiledb_query_t ** query

Creates a TileDB query object. Note that the query object is associated with a specific array object. The query type (read or write) is inferred from the array object, which was opened with a specific query type.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"file:///my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_WRITE);
    tiledb_query_t*query;
    tiledb_query_alloc(ctx,array,TILEDB_WRITE,&query);

ctx

The TileDB context.

query

The query object to be created.

array

An opened array object.

query_type

The query type. This must comply with the query type `array` was opened.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_stats (tiledb_ctx_t *ctx, tiledb_query_t *query, char **stats_json) tiledb_query_get_stats tiledb_ctx_t * ctx tiledb_query_t * query char ** stats_json

Retrieves the stats from a Query.

Example:

    char*stats_json;
    tiledb_query_get_stats(ctx,query,&stats_json);
    //Makesuretofreetheretrieved`stats_json`

ctx

The TileDB context.

query

The query object.

stats_json

The output json. The caller takes ownership of the c-string.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_set_config (tiledb_ctx_t *ctx, tiledb_query_t *query, tiledb_config_t *config) tiledb_query_set_config tiledb_ctx_t * ctx tiledb_query_t * query tiledb_config_t * config

Set the query config

Setting the configuration with this function overrides the following Query-level parameters only:

- `sm.memory_budget`

- `sm.memory_budget_var`

- `sm.var_offsets.mode`

- `sm.var_offsets.extra_element`

- `sm.var_offsets.bitsize`

- `sm.check_coord_dups`

- `sm.check_coord_oob`

- `sm.check_global_order`

- `sm.dedup_coords`

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_config (tiledb_ctx_t *ctx, tiledb_query_t *query, tiledb_config_t **config) tiledb_query_get_config tiledb_ctx_t * ctx tiledb_query_t * query tiledb_config_t ** config

Retrieves the config from a Query.

Example:

    tiledb_config_t*config;
    tiledb_query_get_config(ctx,vfs,&config);
    //Makesuretofreetheretrievedconfig

ctx

The TileDB context.

query

The query object.

config

The config to be retrieved.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_set_subarray (tiledb_ctx_t *ctx, tiledb_query_t *query, const void *subarray) tiledb_query_set_subarray tiledb_ctx_t * ctx tiledb_query_t * query const void * subarray

Indicates that the query will write or read a subarray, and provides the appropriate information.

Example:

The following sets a 2D subarray [0,10], [20, 30] to the query.

    uint64_tsubarray[]={0,10,20,30};
    tiledb_query_set_subarray(ctx,query,subarray);

ctx

The TileDB context.

query

The TileDB query.

subarray

The subarray in which the array read/write will be constrained on. It should be a sequence of [low, high] pairs (one pair per dimension). For the case of writes, this is meaningful only for dense arrays, and specifically dense writes. Note that `subarray` must have the same type as the domain.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

If you set the subarray of a completed, incomplete or in-progress query, this function will clear the internal state and render it as uninitialized. However, the potentially set layout and attribute buffers will be retained. This is useful when the user wishes to fix the attributes and layout, but explore different subarrays with the same `tiledb_query_t` object (i.e., without having to create a new object).

Setting the subarray in sparse writes is meaningless and, thus, this function will error in the following two cases, provided that this is a write query: (i) the array is sparse, and (ii) the array is dense and the layout has been set to `TILEDB_UNORDERED`. In the second case, if the user sets the layout to `TILEDB_UNORDERED` after the subarray has been set, the subarray will simply be ignored.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_query_set_buffer (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, void *buffer, uint64_t *buffer_size) tiledb_query_set_buffer tiledb_ctx_t * ctx tiledb_query_t * query const char * name void * buffer uint64_t * buffer_size

Sets the buffer for a fixed-sized attribute/dimension to a query, which will either hold the values to be written (if it is a write query), or will hold the results from a read query.

Example:

    int32_ta1[100];
    uint64_ta1_size=sizeof(a1);
    tiledb_query_set_buffer(ctx,query,"a1",a1,&a1_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to set the buffer for. Note that zipped coordinates have special name `TILEDB_COORDS`.

buffer

The buffer that either have the input data to be written, or will hold the data to be read.

buffer_size

In the case of writes, this is the size of `buffer` in bytes. In the case of reads, this initially contains the allocated size of `buffer`, but after the termination of the query it will contain the size of the useful (read) data in `buffer`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_query_set_buffer_var (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, uint64_t *buffer_off, uint64_t *buffer_off_size, void *buffer_val, uint64_t *buffer_val_size) tiledb_query_set_buffer_var tiledb_ctx_t * ctx tiledb_query_t * query const char * name uint64_t * buffer_off uint64_t * buffer_off_size void * buffer_val uint64_t * buffer_val_size

Sets the buffer for a var-sized attribute/dimension to a query, which will either hold the values to be written (if it is a write query), or will hold the results from a read query.

Example:

    uint64_ta2_off[10];
    uint64_ta2_off_size=sizeof(a2_off);
    chara2_val[100];
    uint64_ta2_val_size=sizeof(a2_val);
    tiledb_query_set_buffer_var(
    ctx,query,"a2",a2_off,&a2_off_size,a2_val,&a2_val_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to set the buffer for.

buffer_off

The buffer that either have the input data to be written, or will hold the data to be read. This buffer holds the starting offsets of each cell value in `buffer_val`.

buffer_off_size

In the case of writes, it is the size of `buffer_off` in bytes. In the case of reads, this initially contains the allocated size of `buffer_off`, but after the end of the query (`tiledb_query_submit`) it will contain the size of the useful (read) data in `buffer_off`.

buffer_val

The buffer that either have the input data to be written, or will hold the data to be read. This buffer holds the actual var-sized cell values.

buffer_val_size

In the case of writes, it is the size of `buffer_val` in bytes. In the case of reads, this initially contains the allocated size of `buffer_val`, but after the termination of the function it will contain the size of the useful (read) data in `buffer_val`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_query_set_buffer_nullable (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, void *buffer, uint64_t *buffer_size, uint8_t *buffer_validity_bytemap, uint64_t *buffer_validity_bytemap_size) tiledb_query_set_buffer_nullable tiledb_ctx_t * ctx tiledb_query_t * query const char * name void * buffer uint64_t * buffer_size uint8_t * buffer_validity_bytemap uint64_t * buffer_validity_bytemap_size

Sets the buffer for a fixed-sized, nullable attribute to a query, which will either hold the values to be written (if it is a write query), or will hold the results from a read query. The validity buffer is a byte map, where each non-zero byte represents a valid (i.e. "non-null") attribute value.

Example:

    int32_ta1[100];
    uint64_ta1_size=sizeof(a1);
    uint8_ta1_validity[100];
    uint64_ta1_validity_size=sizeof(a1_validity);
    tiledb_query_set_buffer_nullable(
    ctx,query,"a1",a1,&a1_size,a1_validity,&a1_validity_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to set the buffer for. Note that zipped coordinates have special name `TILEDB_COORDS`.

buffer

The buffer that either have the input data to be written, or will hold the data to be read.

buffer_size

In the case of writes, this is the size of `buffer` in bytes. In the case of reads, this initially contains the allocated size of `buffer`, but after the termination of the query it will contain the size of the useful (read) data in `buffer`.

buffer_validity_bytemap

The validity byte map that has exactly one value for each value in `buffer`.

buffer_validity_bytemap_size

In the case of writes, this is the size of `buffer_validity_bytemap` in bytes. In the case of reads, this initially contains the allocated size of `buffer_validity_bytemap`, but after the termination of the query it will contain the size of the useful (read) data in `buffer_validity_bytemap`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_query_set_buffer_var_nullable (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, uint64_t *buffer_off, uint64_t *buffer_off_size, void *buffer_val, uint64_t *buffer_val_size, uint8_t *buffer_validity_bytemap, uint64_t *buffer_validity_bytemap_size) tiledb_query_set_buffer_var_nullable tiledb_ctx_t * ctx tiledb_query_t * query const char * name uint64_t * buffer_off uint64_t * buffer_off_size void * buffer_val uint64_t * buffer_val_size uint8_t * buffer_validity_bytemap uint64_t * buffer_validity_bytemap_size

Sets the buffer for a var-sized, nullable attribute to a query, which will either hold the values to be written (if it is a write query), or will hold the results from a read query.

Example:

    uint64_ta2_off[10];
    uint64_ta2_off_size=sizeof(a2_off);
    chara2_val[100];
    uint64_ta2_val_size=sizeof(a2_val);
    uint8_ta2_validity[100];
    uint64_ta2_validity_size=sizeof(a2_validity);
    tiledb_query_set_buffer_var(
    ctx,query,"a2",a2_off,&a2_off_size,a2_val,&a2_val_size,
    a2_validity,&a2_validity_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to set the buffer for.

buffer_off

The buffer that either have the input data to be written, or will hold the data to be read. This buffer holds the starting offsets of each cell value in `buffer_val`.

buffer_off_size

In the case of writes, it is the size of `buffer_off` in bytes. In the case of reads, this initially contains the allocated size of `buffer_off`, but after the end of the query (`tiledb_query_submit`) it will contain the size of the useful (read) data in `buffer_off`.

buffer_val

The buffer that either have the input data to be written, or will hold the data to be read. This buffer holds the actual var-sized cell values.

buffer_val_size

In the case of writes, it is the size of `buffer_val` in bytes. In the case of reads, this initially contains the allocated size of `buffer_val`, but after the termination of the function it will contain the size of the useful (read) data in `buffer_val`.

buffer_validity_bytemap

The validity byte map that has exactly one value for each value in `buffer`.

buffer_validity_bytemap_size

In the case of writes, this is the size of `buffer_validity_bytemap` in bytes. In the case of reads, this initially contains the allocated size of `buffer_validity_bytemap`, but after the termination of the query it will contain the size of the useful (read) data in `buffer_validity_bytemap`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_set_data_buffer (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, void *buffer, uint64_t *buffer_size) tiledb_query_set_data_buffer tiledb_ctx_t * ctx tiledb_query_t * query const char * name void * buffer uint64_t * buffer_size

Sets the buffer for an attribute/dimension to a query, which will either hold the values to be written (if it is a write query), or will hold the results from a read query.

Example:

    int32_ta1[100];
    uint64_ta1_size=sizeof(a1);
    tiledb_query_set_data_buffer(ctx,query,"a1",a1,&a1_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to set the buffer for. Note that zipped coordinates have special name `TILEDB_COORDS`.

buffer

The buffer that either have the input data to be written, or will hold the data to be read.

buffer_size

In the case of writes, this is the size of `buffer` in bytes. In the case of reads, this initially contains the allocated size of `buffer`, but after the termination of the query it will contain the size of the useful (read) data in `buffer`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_set_offsets_buffer (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, uint64_t *buffer, uint64_t *buffer_size) tiledb_query_set_offsets_buffer tiledb_ctx_t * ctx tiledb_query_t * query const char * name uint64_t * buffer uint64_t * buffer_size

Sets the starting offsets of each cell value in the data buffer.

Example:

    uint64_ta1[100];
    uint64_ta1_size=sizeof(a1);
    tiledb_query_set_offsets_buffer(ctx,query,"a1",a1,&a1_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to set the buffer for. Note that zipped coordinates have special name `TILEDB_COORDS`.

buffer

This buffer holds the starting offsets of each cell value in `buffer_val`.

buffer_size

In the case of writes, it is the size of `buffer_off` in bytes. In the case of reads, this initially contains the allocated size of `buffer_off`, but after the end of the query (`tiledb_query_submit`) it will contain the size of the useful (read) data in `buffer_off`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_set_validity_buffer (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, uint8_t *buffer, uint64_t *buffer_size) tiledb_query_set_validity_buffer tiledb_ctx_t * ctx tiledb_query_t * query const char * name uint8_t * buffer uint64_t * buffer_size

Sets the validity byte map that has exactly one value for each value in the data buffer.

Example:

    uint8_ta1[100];
    uint64_ta1_size=sizeof(a1);
    tiledb_query_set_validity_buffer(ctx,query,"a1",a1,&a1_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to set the buffer for. Note that zipped coordinates have special name `TILEDB_COORDS`.

buffer

The validity byte map that has exactly one value for each value in `buffer`.

buffer_size

In the case of writes, this is the size of `buffer_validity_bytemap` in bytes. In the case of reads, this initially contains the allocated size of `buffer_validity_bytemap`, but after the termination of the query it will contain the size of the useful (read) data in `buffer_validity_bytemap`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_query_get_buffer (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, void **buffer, uint64_t **buffer_size) tiledb_query_get_buffer tiledb_ctx_t * ctx tiledb_query_t * query const char * name void ** buffer uint64_t ** buffer_size

Gets the buffer of a fixed-sized attribute/dimension from a query. If the buffer has not been set, then `buffer` is set to `nullptr`.

Example:

    int*a1;
    uint64_t*a1_size;
    tiledb_query_get_buffer(ctx,query,"a1",&a1,&a1_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to get the buffer for. Note that the zipped coordinates have special name `TILEDB_COORDS`.

buffer

The buffer to retrieve.

buffer_size

A pointer to the size of the buffer. Note that this is a double pointer and returns the original variable address from `set_buffer`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_query_get_buffer_var (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, uint64_t **buffer_off, uint64_t **buffer_off_size, void **buffer_val, uint64_t **buffer_val_size) tiledb_query_get_buffer_var tiledb_ctx_t * ctx tiledb_query_t * query const char * name uint64_t ** buffer_off uint64_t ** buffer_off_size void ** buffer_val uint64_t ** buffer_val_size

Gets the values and offsets buffers for a var-sized attribute/dimension to a query. If the buffers have not been set, then `buffer_off` and `buffer_val` are set to `nullptr`.

Example:

    uint64_t*a2_off;
    uint64_t*a2_off_size;
    char*a2_val;
    uint64_t*a2_val_size;
    tiledb_query_get_buffer_var(
    ctx,query,"a2",&a2_off,&a2_off_size,&a2_val,&a2_val_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to set the buffer for.

buffer_off

The offsets buffer to be retrieved.

buffer_off_size

A pointer to the size of the offsets buffer. Note that this is a `uint_64**` pointer and returns the original variable address from `set_buffer`.

buffer_val

The values buffer to be retrieved.

buffer_val_size

A pointer to the size of the values buffer. Note that this is a `uint_64**` pointer and returns the original variable address from `set_buffer`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_query_get_buffer_nullable (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, void **buffer, uint64_t **buffer_size, uint8_t **buffer_validity_bytemap, uint64_t **buffer_validity_bytemap_size) tiledb_query_get_buffer_nullable tiledb_ctx_t * ctx tiledb_query_t * query const char * name void ** buffer uint64_t ** buffer_size uint8_t ** buffer_validity_bytemap uint64_t ** buffer_validity_bytemap_size

Gets the buffer of a fixed-sized, nullable attribute from a query. If the buffer has not been set, then `buffer` and `buffer_validity_bytemap` are set to `nullptr`.

Example:

    int*a1;
    uint64_t*a1_size;
    uint8_t*a1_validity;
    uint64_t*a1_validity_size;
    tiledb_query_get_buffer_nullable(
    ctx,query,"a1",&a1,&a1_size,&a1_validity,&a1_validity_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to get the buffer for. Note that the zipped coordinates have special name `TILEDB_COORDS`.

buffer

The buffer to retrieve.

buffer_size

A pointer to the size of the buffer. Note that this is a double pointer and returns the original variable address from `set_buffer`.

buffer_validity_bytemap

The validity bytemap buffer to retrieve.

buffer_validity_bytemap_size

A pointer to the size of the validity bytemap buffer. Note that this is a double pointer and returns the origina variable address from `set_buffer_nullable`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_query_get_buffer_var_nullable (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, uint64_t **buffer_off, uint64_t **buffer_off_size, void **buffer_val, uint64_t **buffer_val_size, uint8_t **buffer_validity_bytemap, uint64_t **buffer_validity_bytemap_size) tiledb_query_get_buffer_var_nullable tiledb_ctx_t * ctx tiledb_query_t * query const char * name uint64_t ** buffer_off uint64_t ** buffer_off_size void ** buffer_val uint64_t ** buffer_val_size uint8_t ** buffer_validity_bytemap uint64_t ** buffer_validity_bytemap_size

Gets the values and offsets buffers for a var-sized, nullable attribute to a query. If the buffers have not been set, then `buffer_off`, `buffer_val`, and `buffer_validity_bytemap` are set to `nullptr`.

Example:

    uint64_t*a2_off;
    uint64_t*a2_off_size;
    char*a2_val;
    uint64_t*a2_val_size;
    uint8_t*a2_validity;
    uint64_t*a2_validity_size;
    tiledb_query_get_buffer_var_nullable(
    ctx,query,"a2",&a2_off,&a2_off_size,&a2_val,&a2_val_size,
    &a2_validity,&a2_validity_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to set the buffer for.

buffer_off

The offsets buffer to be retrieved.

buffer_off_size

A pointer to the size of the offsets buffer. Note that this is a `uint_64**` pointer and returns the original variable address from `set_buffer`.

buffer_val

The values buffer to be retrieved.

buffer_val_size

A pointer to the size of the values buffer. Note that this is a `uint_64**` pointer and returns the original variable address from `set_buffer`.

buffer_validity_bytemap

The validity bytemap buffer to retrieve.

buffer_validity_bytemap_size

A pointer to the size of the validity bytemap buffer. Note that this is a double pointer and returns the origina variable address from `set_buffer_var_nullable`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_data_buffer (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, void **buffer, uint64_t **buffer_size) tiledb_query_get_data_buffer tiledb_ctx_t * ctx tiledb_query_t * query const char * name void ** buffer uint64_t ** buffer_size

Gets the buffer of a fixed-sized attribute/dimension from a query. If the buffer has not been set, then `buffer` is set to `nullptr`.

Example:

    int*a1;
    uint64_t*a1_size;
    tiledb_query_get_data_buffer(ctx,query,"a1",&a1,&a1_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to get the buffer for. Note that the zipped coordinates have special name `TILEDB_COORDS`.

buffer

The buffer to retrieve.

buffer_size

A pointer to the size of the buffer. Note that this is a double pointer and returns the original variable address from `set_buffer`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_offsets_buffer (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, uint64_t **buffer, uint64_t **buffer_size) tiledb_query_get_offsets_buffer tiledb_ctx_t * ctx tiledb_query_t * query const char * name uint64_t ** buffer uint64_t ** buffer_size

Gets the starting offsets of each cell value in the data buffer.

Example:

    int*a1;
    uint64_t*a1_size;
    tiledb_query_get_offsets_buffer(ctx,query,"a1",&a1,&a1_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to get the buffer for. Note that the zipped coordinates have special name `TILEDB_COORDS`.

buffer

The buffer to retrieve.

buffer_size

A pointer to the size of the buffer. Note that this is a double pointer and returns the original variable address from `set_buffer`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_validity_buffer (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *name, uint8_t **buffer, uint64_t **buffer_size) tiledb_query_get_validity_buffer tiledb_ctx_t * ctx tiledb_query_t * query const char * name uint8_t ** buffer uint64_t ** buffer_size

Gets the validity byte map that has exactly one value for each value in the data buffer.

Example:

    int*a1;
    uint64_t*a1_size;
    tiledb_query_get_validity_buffer(ctx,query,"a1",&a1,&a1_size);

ctx

The TileDB context.

query

The TileDB query.

name

The attribute/dimension to get the buffer for. Note that the zipped coordinates have special name `TILEDB_COORDS`.

buffer

The buffer to retrieve.

buffer_size

A pointer to the size of the buffer. Note that this is a double pointer and returns the original variable address from `set_buffer`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_set_layout (tiledb_ctx_t *ctx, tiledb_query_t *query, tiledb_layout_t layout) tiledb_query_set_layout tiledb_ctx_t * ctx tiledb_query_t * query tiledb_layout_t layout

Sets the layout of the cells to be written or read.

Example:

    tiledb_query_set_layout(ctx,query,TILEDB_ROW_MAJOR);

ctx

The TileDB context.

query

The TileDB query.

layout

For a write query, this specifies the order of the cells provided by the user in the buffers. For a read query, this specifies the order of the cells that will be retrieved as results and stored in the user buffers. The layout can be one of the following:

- `TILEDB_COL_MAJOR`: This means column-major order with respect to the subarray.

- `TILEDB_ROW_MAJOR`: This means row-major order with respect to the subarray.

- `TILEDB_GLOBAL_ORDER`: This means that cells are stored or retrieved in the array global cell order.

- `TILEDB_UNORDERED`: This is applicable only to reads and writes for sparse arrays, or for sparse writes to dense arrays. For writes, it specifies that the cells are unordered and, hence, TileDB must sort the cells in the global cell order prior to writing. For reads, TileDB will return the cells without any particular order, which will often lead to better performance.

- `TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_set_condition (tiledb_ctx_t *ctx, tiledb_query_t *query, const tiledb_query_condition_t *cond) tiledb_query_set_condition tiledb_ctx_t * ctx tiledb_query_t * query const tiledb_query_condition_t * cond

Sets the query condition to be applied on a read.

Example:

    tiledb_query_condition_t*query_condition;
    tiledb_query_condition_alloc(ctx,&query_condition);
    uint32_tvalue=5;
    tiledb_query_condition_init(
    ctx,query_condition,"longitude",&value,sizeof(value),TILEDB_LT);
    tiledb_query_set_condition(ctx,query,query_condition);

ctx

The TileDB context.

query

The TileDB query.

cond

The TileDB query condition.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_finalize (tiledb_ctx_t *ctx, tiledb_query_t *query) tiledb_query_finalize tiledb_ctx_t * ctx tiledb_query_t * query

Flushes all internal state of a query object and finalizes the query. This is applicable only to global layout writes. It has no effect for any other query type.

Example:

    tiledb_query_t*query;
    //...Yourcodehere...//
    tiledb_query_finalize(ctx,query);

ctx

The TileDB context.

query

The query object to be flushed.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_query_free (tiledb_query_t **query) tiledb_query_free tiledb_query_t ** query

Frees a TileDB query object.

Example:

    tiledb_query_free(&query);

query

The query object to be deleted.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_submit (tiledb_ctx_t *ctx, tiledb_query_t *query) tiledb_query_submit tiledb_ctx_t * ctx tiledb_query_t * query

Submits a TileDB query.

Example:

    tiledb_query_submit(ctx,query);

ctx

The TileDB context.

query

The query to be submitted.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

`tiledb_query_finalize` must be invoked after finish writing in global layout (via repeated invocations of `tiledb_query_submit`), in order to flush any internal state.

For the case of reads, if the returned status is `TILEDB_INCOMPLETE`, TileDB could not fit the entire result in the user's buffers. In this case, the user should consume the read results (if any), optionally reset the buffers with `tiledb_query_set_buffer`, and then resubmit the query until the status becomes `TILEDB_COMPLETED`. If all buffer sizes after the termination of this function become 0, then this means that no useful data was read into the buffers, implying that larger buffers are needed for the query to proceed. In this case, the users must reallocate their buffers (increasing their size), reset the buffers with `tiledb_query_set_buffer`, and resubmit the query.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_submit_async (tiledb_ctx_t *ctx, tiledb_query_t *query, void(*callback)(void *), void *callback_data) tiledb_query_submit_async tiledb_ctx_t * ctx tiledb_query_t * query void(*)(void *) callback void * callback_data

Submits a TileDB query in asynchronous mode.

Examples:

Submit without a callback.

    tiledb_query_submit_async(ctx,query,NULL,NULL);

Submit with a callback function `print` that takes as input message `msg` and prints it upon completion of the query.

    constchar*msg="Querycompleted";
    tiledb_query_submit_async(ctx,&query,foo,msg);

ctx

The TileDB context.

query

The query to be submitted.

callback

The function to be called when the query completes.

callback_data

The data to be passed to the callback function.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

`tiledb_query_finalize` must be invoked after finish writing in global layout (via repeated invocations of `tiledb_query_submit`), in order to flush any internal state.

For the case of reads, if the returned status is `TILEDB_INCOMPLETE`, TileDB could not fit the entire result in the user's buffers. In this case, the user should consume the read results (if any), optionally reset the buffers with `tiledb_query_set_buffer`, and then resubmit the query until the status becomes `TILEDB_COMPLETED`. If all buffer sizes after the termination of this function become 0, then this means that no useful data was read into the buffers, implying that larger buffers are needed for the query to proceed. In this case, the users must reallocate their buffers (increasing their size), reset the buffers with `tiledb_query_set_buffer`, and resubmit the query.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_has_results (tiledb_ctx_t *ctx, tiledb_query_t *query, int32_t *has_results) tiledb_query_has_results tiledb_ctx_t * ctx tiledb_query_t * query int32_t * has_results

Checks if the query has returned any results. Applicable only to read queries; it sets `has_results` to `0 in the case of writes.

Example:

    int32_thas_results;
    tiledb_query_has_results(ctx,query,&has_results);

ctx

The TileDB context.

query

The query.

has_results

Set to `1` if the query returned results and `0` otherwise.

`TILEDB_OK` upon success, and `TILEDB_ERR` upon error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_status (tiledb_ctx_t *ctx, tiledb_query_t *query, tiledb_query_status_t *status) tiledb_query_get_status tiledb_ctx_t * ctx tiledb_query_t * query tiledb_query_status_t * status

Retrieves the status of a query.

Example:

    tiledb_query_status_tstatus;
    tiledb_query_get_status(ctx,query,&status);

ctx

The TileDB context.

query

The query.

status

The query status to be retrieved.

`TILEDB_OK` upon success, and `TILEDB_ERR` upon error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_type (tiledb_ctx_t *ctx, tiledb_query_t *query, tiledb_query_type_t *query_type) tiledb_query_get_type tiledb_ctx_t * ctx tiledb_query_t * query tiledb_query_type_t * query_type

Retrieves the query type.

Example:

    tiledb_query_type_tquery_type;
    tiledb_query_get_status(ctx,query,&query_type);

ctx

The TileDB context.

query

The query.

query_type

The query type to be retrieved.

`TILEDB_OK` upon success, and `TILEDB_ERR` upon error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_layout (tiledb_ctx_t *ctx, tiledb_query_t *query, tiledb_layout_t *query_layout) tiledb_query_get_layout tiledb_ctx_t * ctx tiledb_query_t * query tiledb_layout_t * query_layout

Retrieves the query layout.

Example:

    tiledb_layout_tquery_layout;
    tiledb_query_get_layout(ctx,query,&query_layout);

ctx

The TileDB context.

query

The query.

query_layout

The query layout to be retrieved.

`TILEDB_OK` upon success, and `TILEDB_ERR` upon error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_array (tiledb_ctx_t *ctx, tiledb_query_t *query, tiledb_array_t **array) tiledb_query_get_array tiledb_ctx_t * ctx tiledb_query_t * query tiledb_array_t ** array

Retrieves the query array.

Example:

    tiledb_array_t*array;
    tiledb_query_get_array(ctx,query,&array);

ctx

The TileDB context.

query

The query.

array

The query array to be retrieved.

`TILEDB_OK` upon success, and `TILEDB_ERR` upon error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_add_range (tiledb_ctx_t *ctx, tiledb_query_t *query, uint32_t dim_idx, const void *start, const void *end, const void *stride) tiledb_query_add_range tiledb_ctx_t * ctx tiledb_query_t * query uint32_t dim_idx const void * start const void * end const void * stride

Adds a 1D range along a subarray dimension index, which is in the form (start, end, stride). The datatype of the range components must be the same as the type of the domain of the array in the query.

Example:

    uint32_tdim_idx=2;
    int64_tstart=10;
    int64_tend=20;
    tiledb_query_add_range(ctx,query,dim_idx,&start,&end,nullptr);

ctx

The TileDB context.

query

The query to add the range to.

dim_idx

The index of the dimension to add the range to.

start

The range start.

end

The range end.

stride

The range stride.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

The stride is currently unsupported. Use `nullptr` as the stride argument.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_add_range_by_name (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *dim_name, const void *start, const void *end, const void *stride) tiledb_query_add_range_by_name tiledb_ctx_t * ctx tiledb_query_t * query const char * dim_name const void * start const void * end const void * stride

Adds a 1D range along a subarray dimension name, which is in the form (start, end, stride). The datatype of the range components must be the same as the type of the domain of the array in the query.

Example:

    uint32_tdim_name="rows";
    int64_tstart=10;
    int64_tend=20;
    tiledb_query_add_range_by_name(ctx,query,dim_name,&start,&end,nullptr);

ctx

The TileDB context.

query

The query to add the range to.

dim_name

The name of the dimension to add the range to.

start

The range start.

end

The range end.

stride

The range stride.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

The stride is currently unsupported. Use `nullptr` as the stride argument.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_add_range_var (tiledb_ctx_t *ctx, tiledb_query_t *query, uint32_t dim_idx, const void *start, uint64_t start_size, const void *end, uint64_t end_size) tiledb_query_add_range_var tiledb_ctx_t * ctx tiledb_query_t * query uint32_t dim_idx const void * start uint64_t start_size const void * end uint64_t end_size

Adds a 1D variable-sized range along a subarray dimension index, which is in the form (start, end). Applicable only to variable-sized dimensions.

Example:

    uint32_tdim_idx=2;
    charstart[]="a";
    charend[]="bb";
    tiledb_query_add_range_var(ctx,query,dim_idx,start,1,end,2);

ctx

The TileDB context.

query

The query to add the range to.

dim_idx

The index of the dimension to add the range to.

start

The range start.

start_size

The size of the range start in bytes.

end

The range end.

end_size

The size of the range end in bytes.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_add_range_var_by_name (tiledb_ctx_t *ctx, tiledb_query_t *query, const char *dim_name, const void *start, uint64_t start_size, const void *end, uint64_t end_size) tiledb_query_add_range_var_by_name tiledb_ctx_t * ctx tiledb_query_t * query const char * dim_name const void * start uint64_t start_size const void * end uint64_t end_size

Adds a 1D variable-sized range along a subarray dimension name, which is in the form (start, end). Applicable only to variable-sized dimensions.

Example:

    uint32_tdim_name="rows";
    charstart[]="a";
    charend[]="bb";
    tiledb_query_add_range_var_by_name(ctx,query,dim_name,start,1,end,2);

ctx

The TileDB context.

query

The query to add the range to.

dim_name

The name of the dimension to add the range to.

start

The range start.

start_size

The size of the range start in bytes.

end

The range end.

end_size

The size of the range end in bytes.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_range_num (tiledb_ctx_t *ctx, const tiledb_query_t *query, uint32_t dim_idx, uint64_t *range_num) tiledb_query_get_range_num tiledb_ctx_t * ctx const tiledb_query_t * query uint32_t dim_idx uint64_t * range_num

Retrieves the number of ranges of the query subarray along a given dimension index.

Example:

    uint64_trange_num;
    tiledb_query_get_range_num(ctx,query,dim_idx,&range_num);

ctx

The TileDB context

query

The query.

dim_idx

The index of the dimension whose range number to retrieve.

range_num

The number of ranges to retrieve.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_range_num_from_name (tiledb_ctx_t *ctx, const tiledb_query_t *query, const char *dim_name, uint64_t *range_num) tiledb_query_get_range_num_from_name tiledb_ctx_t * ctx const tiledb_query_t * query const char * dim_name uint64_t * range_num

Retrieves the number of ranges of the query subarray along a given dimension name.

Example:

    uint64_trange_num;
    tiledb_query_get_range_num_from_name(ctx,query,dim_name,&range_num);

ctx

The TileDB context

query

The query.

dim_name

The name of the dimension whose range number to retrieve.

range_num

The number of ranges to retrieve.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_range (tiledb_ctx_t *ctx, const tiledb_query_t *query, uint32_t dim_idx, uint64_t range_idx, const void **start, const void **end, const void **stride) tiledb_query_get_range tiledb_ctx_t * ctx const tiledb_query_t * query uint32_t dim_idx uint64_t range_idx const void ** start const void ** end const void ** stride

Retrieves a specific range of the query subarray along a given dimension index.

Example:

    constvoid*start;
    constvoid*end;
    constvoid*stride;
    tiledb_query_get_range(
    ctx,query,dim_idx,range_idx,&start,&end,&stride);

ctx

The TileDB context

query

The query.

dim_idx

The index of the dimension to retrieve the range from.

range_idx

The index of the range to retrieve.

start

The range start to retrieve.

end

The range end to retrieve.

stride

The range stride to retrieve.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_range_from_name (tiledb_ctx_t *ctx, const tiledb_query_t *query, const char *dim_name, uint64_t range_idx, const void **start, const void **end, const void **stride) tiledb_query_get_range_from_name tiledb_ctx_t * ctx const tiledb_query_t * query const char * dim_name uint64_t range_idx const void ** start const void ** end const void ** stride

Retrieves a specific range of the query subarray along a given dimension name.

Example:

    constvoid*start;
    constvoid*end;
    constvoid*stride;
    tiledb_query_get_range_from_name(
    ctx,query,dim_name,range_idx,&start,&end,&stride);

ctx

The TileDB context

query

The query.

dim_name

The name of the dimension to retrieve the range from.

range_idx

The index of the range to retrieve.

start

The range start to retrieve.

end

The range end to retrieve.

stride

The range stride to retrieve.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_range_var_size (tiledb_ctx_t *ctx, const tiledb_query_t *query, uint32_t dim_idx, uint64_t range_idx, uint64_t *start_size, uint64_t *end_size) tiledb_query_get_range_var_size tiledb_ctx_t * ctx const tiledb_query_t * query uint32_t dim_idx uint64_t range_idx uint64_t * start_size uint64_t * end_size

Retrieves a range's start and end size for a given variable-length dimension index at a given range index.

Example:

    uint64_tstart_size;
    uint64_tend_size;
    tiledb_query_get_range_var_size(
    ctx,query,dim_idx,range_idx,&start_size,&end_size);

ctx

The TileDB context

query

The query.

dim_idx

The index of the dimension to retrieve the range from.

range_idx

The index of the range to retrieve.

start_size

range start size in bytes

end_size

range end size in bytes

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_range_var_size_from_name (tiledb_ctx_t *ctx, const tiledb_query_t *query, const char *dim_name, uint64_t range_idx, uint64_t *start_size, uint64_t *end_size) tiledb_query_get_range_var_size_from_name tiledb_ctx_t * ctx const tiledb_query_t * query const char * dim_name uint64_t range_idx uint64_t * start_size uint64_t * end_size

Retrieves a range's start and end size for a given variable-length dimension name at a given range index.

Example:

    uint64_tstart_size;
    uint64_tend_size;
    tiledb_query_get_range_var_size_from_name(
    ctx,query,dim_name,range_idx,&start_size,&end_size);

ctx

The TileDB context

query

The query.

dim_name

The name of the dimension to retrieve the range from.

range_idx

The index of the range to retrieve.

start_size

range start size in bytes

end_size

range end size in bytes

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_range_var (tiledb_ctx_t *ctx, const tiledb_query_t *query, uint32_t dim_idx, uint64_t range_idx, void *start, void *end) tiledb_query_get_range_var tiledb_ctx_t * ctx const tiledb_query_t * query uint32_t dim_idx uint64_t range_idx void * start void * end

Retrieves a specific range of the query subarray along a given variable-length dimension index.

Example:

    constvoid*start;
    constvoid*end;
    tiledb_query_get_range_var(
    ctx,query,dim_idx,range_idx,&start,&end);

ctx

The TileDB context

query

The query.

dim_idx

The index of the dimension to retrieve the range from.

range_idx

The index of the range to retrieve.

start

The range start to retrieve.

end

The range end to retrieve.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_range_var_from_name (tiledb_ctx_t *ctx, const tiledb_query_t *query, const char *dim_name, uint64_t range_idx, void *start, void *end) tiledb_query_get_range_var_from_name tiledb_ctx_t * ctx const tiledb_query_t * query const char * dim_name uint64_t range_idx void * start void * end

Retrieves a specific range of the query subarray along a given variable-length dimension name.

Example:

    constvoid*start;
    constvoid*end;
    tiledb_query_get_range_var_from_name(
    ctx,query,dim_name,range_idx,&start,&end);

ctx

The TileDB context

query

The query.

dim_name

The name of the dimension to retrieve the range from.

range_idx

The index of the range to retrieve.

start

The range start to retrieve.

end

The range end to retrieve.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_est_result_size (tiledb_ctx_t *ctx, const tiledb_query_t *query, const char *name, uint64_t *size) tiledb_query_get_est_result_size tiledb_ctx_t * ctx const tiledb_query_t * query const char * name uint64_t * size

Retrieves the estimated result size for a fixed-sized attribute/dimension.

Example:

    uint64_tsize;
    tiledb_query_get_est_result_size(ctx,query,"a",&size);

ctx

The TileDB context

query

The query.

name

The attribute/dimension name.

size

The size (in bytes) to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_est_result_size_var (tiledb_ctx_t *ctx, const tiledb_query_t *query, const char *name, uint64_t *size_off, uint64_t *size_val) tiledb_query_get_est_result_size_var tiledb_ctx_t * ctx const tiledb_query_t * query const char * name uint64_t * size_off uint64_t * size_val

Retrieves the estimated result size for a var-sized attribute/dimension.

Example:

    uint64_tsize_off,size_val;
    tiledb_query_get_est_result_size_var(
    ctx,query,"a",&size_off,&size_val);

ctx

The TileDB context

query

The query.

name

The attribute/dimension name.

size_off

The size of the offsets (in bytes) to be retrieved.

size_val

The size of the values (in bytes) to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_est_result_size_nullable (tiledb_ctx_t *ctx, const tiledb_query_t *query, const char *name, uint64_t *size_val, uint64_t *size_validity) tiledb_query_get_est_result_size_nullable tiledb_ctx_t * ctx const tiledb_query_t * query const char * name uint64_t * size_val uint64_t * size_validity

Retrieves the estimated result size for a fixed-sized, nullable attribute.

Example:

    uint64_tsize_val;
    uint64_tsize_validity;
    tiledb_query_get_est_result_size_nullable(ctx,query,"a",&size_val,
    &size_validity);

ctx

The TileDB context

query

The query.

name

The attribute name.

size_val

The size of the values (in bytes) to be retrieved.

size_validity

The size of the validity values (in bytes) to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_est_result_size_var_nullable (tiledb_ctx_t *ctx, const tiledb_query_t *query, const char *name, uint64_t *size_off, uint64_t *size_val, uint64_t *size_validity) tiledb_query_get_est_result_size_var_nullable tiledb_ctx_t * ctx const tiledb_query_t * query const char * name uint64_t * size_off uint64_t * size_val uint64_t * size_validity

Retrieves the estimated result size for a var-sized, nullable attribute.

Example:

    uint64_tsize_off,size_val,size_validity;
    tiledb_query_get_est_result_size_var_nullable(
    ctx,query,"a",&size_off,&size_val,&size_validity);

ctx

The TileDB context

query

The query.

name

The attribute name.

size_off

The size of the offsets (in bytes) to be retrieved.

size_val

The size of the values (in bytes) to be retrieved.

size_validity

The size of the validity values (in bytes) to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_fragment_num (tiledb_ctx_t *ctx, const tiledb_query_t *query, uint32_t *num) tiledb_query_get_fragment_num tiledb_ctx_t * ctx const tiledb_query_t * query uint32_t * num

Retrieves the number of written fragments. Applicable only to WRITE queries.

Example:

    uint32_tnum;
    tiledb_query_get_fragment_num(ctx,query,&num);

ctx

The TileDB context

query

The query.

num

The number of written fragments to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_fragment_uri (tiledb_ctx_t *ctx, const tiledb_query_t *query, uint64_t idx, const char **uri) tiledb_query_get_fragment_uri tiledb_ctx_t * ctx const tiledb_query_t * query uint64_t idx const char ** uri

Retrieves the URI of the written fragment with the input index. Applicable only to WRITE queries.

Example:

    constchar*uri;
    tiledb_query_get_fragment_uri(
    ctx,query,0,&uri);

ctx

The TileDB context

query

The query.

idx

The index of the written fragment.

uri

The URI of the written fragment to be returned.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

Make sure to make a copy of `uri` after its retrieval, as the constant pointer may be updated internally as new fragments are being written.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_get_fragment_timestamp_range (tiledb_ctx_t *ctx, const tiledb_query_t *query, uint64_t idx, uint64_t *t1, uint64_t *t2) tiledb_query_get_fragment_timestamp_range tiledb_ctx_t * ctx const tiledb_query_t * query uint64_t idx uint64_t * t1 uint64_t * t2

Retrieves the timestamp range of the written fragment with the input index. Applicable only to WRITE queries.

Example:

    uint64_tt1,t2;
    tiledb_query_get_fragment_timestamp_range(
    ctx,query,0,&t1,&t2);

ctx

The TileDB context

query

The query.

idx

The index of the written fragment.

t1

The start value of the timestamp range of the written fragment to be returned.

t2

The end value of the timestamp range of the written fragment to be returned.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_condition_alloc (tiledb_ctx_t *ctx, tiledb_query_condition_t **cond) tiledb_query_condition_alloc tiledb_ctx_t * ctx tiledb_query_condition_t ** cond

Allocates a TileDB query condition object.

Example:

    tiledb_query_condition_t*query_condition;
    tiledb_query_condition_alloc(ctx,&query_condition);

ctx

The TileDB context.

cond

The allocated query condition object.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_query_condition_free (tiledb_query_condition_t **cond) tiledb_query_condition_free tiledb_query_condition_t ** cond

Frees a TileDB query condition object.

Example:

    uint32_tvalue=5;
    tiledb_query_condition_t*query_condition;
    tiledb_query_condition_alloc(
    ctx,"longitude",&value,sizeof(value),TILEDB_LT,&query_condition);
    tiledb_query_set_condition(ctx,query,query_condition);
    tiledb_query_submit(ctx,query);
    tiledb_query_condition_free(&query_condition);

cond

The query condition object to be freed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_condition_init (tiledb_ctx_t *ctx, tiledb_query_condition_t *cond, const char *attribute_name, const void *condition_value, uint64_t condition_value_size, tiledb_query_condition_op_t op) tiledb_query_condition_init tiledb_ctx_t * ctx tiledb_query_condition_t * cond const char * attribute_name const void * condition_value uint64_t condition_value_size tiledb_query_condition_op_t op

Initializes a TileDB query condition object.

Example:

    tiledb_query_condition_t*query_condition;
    tiledb_query_condition_alloc(ctx,&query_condition);

    uint32_tvalue=5;
    tiledb_query_condition_init(
    ctx,query_condition,"longitude",&value,sizeof(value),TILEDB_LT);

ctx

The TileDB context.

cond

The allocated query condition object.

attribute_name

The attribute name.

condition_value

The value to compare against an attribute value.

condition_value_size

The byte size of `condition_value`.

op

The comparison operator.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_query_condition_combine (tiledb_ctx_t *ctx, const tiledb_query_condition_t *left_cond, const tiledb_query_condition_t *right_cond, tiledb_query_condition_combination_op_t combination_op, tiledb_query_condition_t **combined_cond) tiledb_query_condition_combine tiledb_ctx_t * ctx const tiledb_query_condition_t * left_cond const tiledb_query_condition_t * right_cond tiledb_query_condition_combination_op_t combination_op tiledb_query_condition_t ** combined_cond

Combines two query condition objects into a newly allocated condition. Does not mutate or free the input condition objects.

Example:

    tiledb_query_condition_t*query_condition_1;
    tiledb_query_condition_alloc(ctx,&query_condition_1);
    uint32_tvalue_1=5;
    tiledb_query_condition_init(
    ctx,
    query_condition_1,
    "longitude",
    &value_1,
    sizeof(value_1),
    TILEDB_LT);

    tiledb_query_condition_t*query_condition_2;
    tiledb_query_condition_alloc(ctx,&query_condition_2);
    uint32_tvalue_2=20;
    tiledb_query_condition_init(
    ctx,
    query_condition_2,
    "latitude",
    &value_2,
    sizeof(value_2),
    TILEDB_GE);

    tiledb_query_condition_t*query_condition_3;
    tiledb_query_condition_combine(
    ctx,query_condition_1,query_condition_2,TILEDB_AND,&query_condition_3);

    tiledb_query_condition_free(&query_condition_1);
    tiledb_query_condition_free(&query_condition_2);

    tiledb_query_set_condition(ctx,query,query_condition_3);
    tiledb_query_submit(ctx,query);
    tiledb_query_condition_free(&query_condition_3);

ctx

The TileDB context.

attribute_name

The attribute name.

condition_value

The value to compare against an attribute value.

condition_value_size

The byte size of `condition_value`.

op

The comparison operator.

cond

The allocated query condition object.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_alloc (tiledb_ctx_t *ctx, const char *array_uri, tiledb_array_t **array) tiledb_array_alloc tiledb_ctx_t * ctx const char * array_uri tiledb_array_t ** array

Allocates a TileDB array object.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"hdfs:///tiledb_arrays/my_array",&array);

ctx

The TileDB context.

array_uri

The array URI.

array

The array object to be created.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_set_open_timestamp_start (tiledb_ctx_t *ctx, tiledb_array_t *array, uint64_t timestamp_start) tiledb_array_set_open_timestamp_start tiledb_ctx_t * ctx tiledb_array_t * array uint64_t timestamp_start

Sets the starting timestamp to use when opening (and reopening) the array. This is an inclusive bound. The default value is `0`.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"s3://tiledb_bucket/my_array",&array);
    tiledb_array_set_open_timestamp_start(ctx,array,1234);
    tiledb_array_open(ctx,array,TILEDB_READ);

ctx

The TileDB context.

array

The array to set the timestamp on.

timestamp_start

The epoch timestamp in milliseconds.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_set_open_timestamp_end (tiledb_ctx_t *ctx, tiledb_array_t *array, uint64_t timestamp_end) tiledb_array_set_open_timestamp_end tiledb_ctx_t * ctx tiledb_array_t * array uint64_t timestamp_end

Sets the ending timestamp to use when opening (and reopening) the array. This is an inclusive bound. The UINT64_MAX timestamp is a reserved timestamp that will be interpretted as the current timestamp when an array is opened. The default value is `UINT64_MAX`.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"s3://tiledb_bucket/my_array",&array);
    tiledb_array_set_open_timestamp_end(ctx,array,5678);
    tiledb_array_open(ctx,array,TILEDB_READ);

ctx

The TileDB context.

array

The array to set the timestamp on.

timestamp_end

The epoch timestamp in milliseconds. Use UINT64_MAX for the current timestamp.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_open_timestamp_start (tiledb_ctx_t *ctx, tiledb_array_t *array, uint64_t *timestamp_start) tiledb_array_get_open_timestamp_start tiledb_ctx_t * ctx tiledb_array_t * array uint64_t * timestamp_start

Gets the starting timestamp used when opening (and reopening) the array. This is an inclusive bound.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"s3://tiledb_bucket/my_array",&array);
    tiledb_array_set_open_timestamp_start(ctx,array,1234);
    tiledb_array_open(ctx,array,TILEDB_READ);

    uint64_ttimestamp_start;
    tiledb_array_get_open_timestamp_start(ctx,array,&timestamp_start);
    assert(timestamp_start==1234);

ctx

The TileDB context.

array

The array to set the timestamp on.

timestamp_start

The output epoch timestamp in milliseconds.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_open_timestamp_end (tiledb_ctx_t *ctx, tiledb_array_t *array, uint64_t *timestamp_end) tiledb_array_get_open_timestamp_end tiledb_ctx_t * ctx tiledb_array_t * array uint64_t * timestamp_end

Gets the ending timestamp used when opening (and reopening) the array. This is an inclusive bound. If UINT64_MAX was set, this will return the timestamp at the time the array was opened. If the array has not yet been opened, it will return UINT64_MAX.`

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"s3://tiledb_bucket/my_array",&array);
    tiledb_array_set_open_timestamp_end(ctx,array,5678);
    tiledb_array_open(ctx,array,TILEDB_READ);

    uint64_ttimestamp_end;
    tiledb_array_get_open_timestamp_end(ctx,array,&timestamp_end);
    assert(timestamp_start==5678);

ctx

The TileDB context.

array

The array to set the timestamp on.

timestamp_end

The output epoch timestamp in milliseconds.

`TILEDB_OK` for success or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_open (tiledb_ctx_t *ctx, tiledb_array_t *array, tiledb_query_type_t query_type) tiledb_array_open tiledb_ctx_t * ctx tiledb_array_t * array tiledb_query_type_t query_type

Opens a TileDB array. The array is opened using a query type as input. This is to indicate that queries created for this `tiledb_array_t` object will inherit the query type. In other words, `tiledb_array_t` objects are opened to receive only one type of queries. They can always be closed and be re-opened with another query type. Also there may be many different `tiledb_array_t` objects created and opened with different query types.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"hdfs:///tiledb_arrays/my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);

ctx

The TileDB context.

array

The array object to be opened.

query_type

The type of queries the array object will be receiving.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

If the same array object is opened again without being closed, an error will be thrown.

The config should be set before opening an array.

If the array is to be opened at a specfic time interval, the `timestamp{start, end}` values should be set to a config that's set to the array object before opening the array.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_array_open_at (tiledb_ctx_t *ctx, tiledb_array_t *array, tiledb_query_type_t query_type, uint64_t timestamp) tiledb_array_open_at tiledb_ctx_t * ctx tiledb_array_t * array tiledb_query_type_t query_type uint64_t timestamp

Similar to `tiledb_array_open`, but this function takes as input a timestamp, representing time in milliseconds ellapsed since 1970-01-01 00:00:00 +0000 (UTC). Opening the array at a timestamp provides a view of the array with all writes/updates that happened at or before `timestamp` (i.e., excluding those that occurred after `timestamp`). This function is useful to ensure consistency at a potential distributed setting, where machines need to operate on the same view of the array.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"hdfs:///tiledb_arrays/my_array",&array);
    //Assuming`timestamp`istimerepresentedinmilliseconds:
    tiledb_array_open_at(ctx,array,TILEDB_READ,timestamp);

ctx

The TileDB context.

array

The array object to be opened.

query_type

The type of queries the array object will be receiving.

timestamp

The timestamp to open the array at.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

If the same array object is opened again without being closed, an error will be thrown.

This function is applicable only to read queries.

The config should be set before opening an array.

If the array is to be opened at a specfic time interval, the `timestamp{start, end}` values should be set to a config that's set to the array object before opening the array.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_array_open_with_key (tiledb_ctx_t *ctx, tiledb_array_t *array, tiledb_query_type_t query_type, tiledb_encryption_type_t encryption_type, const void *encryption_key, uint32_t key_length) tiledb_array_open_with_key tiledb_ctx_t * ctx tiledb_array_t * array tiledb_query_type_t query_type tiledb_encryption_type_t encryption_type const void * encryption_key uint32_t key_length

Opens an encrypted array using the given encryption key. This function has the same semantics as `tiledb_array_open()` but is used for encrypted arrays.

An encrypted array must be opened with this function before queries can be issued to it.

Example:

    //LoadAES-256keyfromdisk,environmentvariable,etc.
    uint8_tkey[32]=...;
    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"hdfs:///tiledb_arrays/my_array",&array);
    tiledb_array_open_with_key(ctx,array,TILEDB_READ,
    TILEDB_AES_256_GCM,key,sizeof(key));

ctx

The TileDB context.

array

The array object to be opened.

query_type

The type of queries the array object will be receiving.

encryption_type

The encryption type to use.

encryption_key

The encryption key to use.

key_length

Length in bytes of the encryption key.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

The config should be set before opening an array.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_array_open_at_with_key (tiledb_ctx_t *ctx, tiledb_array_t *array, tiledb_query_type_t query_type, tiledb_encryption_type_t encryption_type, const void *encryption_key, uint32_t key_length, uint64_t timestamp) tiledb_array_open_at_with_key tiledb_ctx_t * ctx tiledb_array_t * array tiledb_query_type_t query_type tiledb_encryption_type_t encryption_type const void * encryption_key uint32_t key_length uint64_t timestamp

Similar to `tiledb_array_open_with_key`, but this function takes as input a timestamp, representing time in milliseconds ellapsed since 1970-01-01 00:00:00 +0000 (UTC). Opening the array at a timestamp provides a view of the array with all writes/updates that happened at or before `timestamp` (i.e., excluding those that occurred after `timestamp`). This function is useful to ensure consistency at a potential distributed setting, where machines need to operate on the same view of the array.

Example:

    //LoadAES-256keyfromdisk,environmentvariable,etc.
    uint8_tkey[32]=...;
    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"hdfs:///tiledb_arrays/my_array",&array);
    //Assuming`timestamp`istimerepresentedinmilliseconds:
    tiledb_array_open_at_with_key(ctx,array,TILEDB_READ,
    TILEDB_AES_256_GCM,key,sizeof(key),timestamp);

ctx

The TileDB context.

array

The array object to be opened.

query_type

The type of queries the array object will be receiving.

encryption_type

The encryption type to use.

encryption_key

The encryption key to use.

key_length

Length in bytes of the encryption key.

timestamp

The timestamp to open the array at.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

If the same array object is opened again without being closed, an error will be thrown.

This function is applicable only to read queries.

The config should be set before opening an array.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_is_open (tiledb_ctx_t *ctx, tiledb_array_t *array, int32_t *is_open) tiledb_array_is_open tiledb_ctx_t * ctx tiledb_array_t * array int32_t * is_open

Checks if the array is open.

ctx

The TileDB context.

array

The array to be checked.

is_open

`1` if the array is open and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_reopen (tiledb_ctx_t *ctx, tiledb_array_t *array) tiledb_array_reopen tiledb_ctx_t * ctx tiledb_array_t * array

Reopens a TileDB array (the array must be already open). This is useful when the array got updated after it got opened and the `tiledb_array_t` object got created. To sync-up with the updates, the user must either close the array and open with `tiledb_array_open`, or just use `tiledb_array_reopen` without closing. This function will be generally faster than the former alternative.

Note: reopening encrypted arrays does not require the encryption key.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"hdfs:///tiledb_arrays/my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    tiledb_array_reopen(ctx,array);

ctx

The TileDB context.

array

The array object to be re-opened.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

This is applicable only to arrays opened for reads.

If the array is to be reopened after opening at a specfic time interval, the `timestamp{start, end}` values and subsequent config object should be reset for the array before reopening.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_array_reopen_at (tiledb_ctx_t *ctx, tiledb_array_t *array, uint64_t timestamp) tiledb_array_reopen_at tiledb_ctx_t * ctx tiledb_array_t * array uint64_t timestamp

Reopens a TileDB array (the array must be already open) at a specific timestamp.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"hdfs:///tiledb_arrays/my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    uint64_ttimestamp=tiledb_timestamp_now_ms();
    tiledb_array_reopen_at(ctx,array,timestamp);

ctx

The TileDB context.

array

The array object to be re-opened.

timestamp

Timestamp at which to reopen.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

This is applicable only to arrays opened for reads.

If the array is to be reopened after opening at a specfic time interval, the `timestamp{start, end}` values and subsequent config object should be reset for the array before reopening.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_array_get_timestamp (tiledb_ctx_t *ctx, tiledb_array_t *array, uint64_t *timestamp) tiledb_array_get_timestamp tiledb_ctx_t * ctx tiledb_array_t * array uint64_t * timestamp

The start/end timestamps for opening an array are now set in the config.

Returns the timestamp, representing time in milliseconds ellapsed since 1970-01-01 00:00:00 +0000 (UTC), at which the array was opened. See also the documentation of `tiledb_array_open_at`.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"s3://tiledb_bucket/my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    //Getthetimestampthearrayatwhichthearraywasopened.
    uint64_ttimestamp;
    tiledb_array_get_timestamp(ctx,array,&timestamp);

ctx

The TileDB context.

array

The array to retrieve the timestamp for.

timestamp

Set to the timestamp at which the array was opened.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

The array does not need to be open to use this function.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_set_config (tiledb_ctx_t *ctx, tiledb_array_t *array, tiledb_config_t *config) tiledb_array_set_config tiledb_ctx_t * ctx tiledb_array_t * array tiledb_config_t * config

Sets the array config.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"s3://tiledb_bucket/my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    //Settheconfigforthegivenarray.
    tiledb_config_t*config;
    tiledb_array_set_config(ctx,array,config);

ctx

The TileDB context.

array

The array to set the config for.

config

The config to be set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

The array does not need to be opened via `tiledb_array_open_at` to use this function.

The config should be set before opening an array.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_config (tiledb_ctx_t *ctx, tiledb_array_t *array, tiledb_config_t **config) tiledb_array_get_config tiledb_ctx_t * ctx tiledb_array_t * array tiledb_config_t ** config

Gets the array config.

Example:

    //Retrievetheconfigforthegivenarray.
    tiledb_config_t*config;
    tiledb_array_get_config(ctx,array,config);

ctx

The TileDB context.

array

The array to set the config for.

config

Set to the retrieved config.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_close (tiledb_ctx_t *ctx, tiledb_array_t *array) tiledb_array_close tiledb_ctx_t * ctx tiledb_array_t * array

Closes a TileDB array.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"hdfs:///tiledb_arrays/my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    tiledb_array_close(ctx,array);

ctx

The TileDB context.

array

The array object to be closed.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

If the array object has already been closed, the function has no effect.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_array_free (tiledb_array_t **array) tiledb_array_free tiledb_array_t ** array

Frees a TileDB array object.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"hdfs:///tiledb_arrays/my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    tiledb_array_close(ctx,array);
    tiledb_array_free(&array);

array

The array object to be freed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_schema (tiledb_ctx_t *ctx, tiledb_array_t *array, tiledb_array_schema_t **array_schema) tiledb_array_get_schema tiledb_ctx_t * ctx tiledb_array_t * array tiledb_array_schema_t ** array_schema

Retrieves the schema of an array.

Example:

    tiledb_array_schema_t*array_schema;
    tiledb_array_get_schema(ctx,array,&array_schema);

ctx

The TileDB context.

array

The open array.

array_schema

The array schema to be retrieved.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

The user must free the array schema with `tiledb_array_schema_free`.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_query_type (tiledb_ctx_t *ctx, tiledb_array_t *array, tiledb_query_type_t *query_type) tiledb_array_get_query_type tiledb_ctx_t * ctx tiledb_array_t * array tiledb_query_type_t * query_type

Retrieves the query type with which the array was opened.

Example:

    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"hdfs:///tiledb_arrays/my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    tiledb_query_type_tquery_type;
    tiledb_array_get_type(ctx,array,&query_type);

ctx

The TileDB context.

array

The array.

query_type

The query type to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_create (tiledb_ctx_t *ctx, const char *array_uri, const tiledb_array_schema_t *array_schema) tiledb_array_create tiledb_ctx_t * ctx const char * array_uri const tiledb_array_schema_t * array_schema

Creates a new TileDB array given an input schema.

Example:

    tiledb_array_create(ctx,"hdfs:///tiledb_arrays/my_array",array_schema);

ctx

The TileDB context.

array_uri

The array name.

array_schema

The array schema.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_array_create_with_key (tiledb_ctx_t *ctx, const char *array_uri, const tiledb_array_schema_t *array_schema, tiledb_encryption_type_t encryption_type, const void *encryption_key, uint32_t key_length) tiledb_array_create_with_key tiledb_ctx_t * ctx const char * array_uri const tiledb_array_schema_t * array_schema tiledb_encryption_type_t encryption_type const void * encryption_key uint32_t key_length

Creates a new encrypted TileDB array given an input schema.

Encrypted arrays can only be created through this function.

Example:

    uint8_tkey[32]=...;
    tiledb_array_create_with_key(
    ctx,"hdfs:///tiledb_arrays/my_array",array_schema,
    TILEDB_AES_256_GCM,key,sizeof(key));

ctx

The TileDB context.

array_uri

The array name.

array_schema

The array schema.

encryption_type

The encryption type to use.

encryption_key

The encryption key to use.

key_length

Length in bytes of the encryption key.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_consolidate (tiledb_ctx_t *ctx, const char *array_uri, tiledb_config_t *config) tiledb_array_consolidate tiledb_ctx_t * ctx const char * array_uri tiledb_config_t * config

Depending on the consoliation mode in the config, consolidates either the fragment files, fragment metadata files, or array metadata files into a single file.

You must first finalize all queries to the array before consolidation can begin (as consolidation temporarily acquires an exclusive lock on the array).

Example:

    tiledb_array_consolidate(
    ctx,"hdfs:///tiledb_arrays/my_array",nullptr);

ctx

The TileDB context.

array_uri

The name of the TileDB array whose metadata will be consolidated.

config

Configuration parameters for the consolidation (`nullptr` means default, which will use the config from `ctx`). The `sm.consolidation.mode` parameter determines which type of consolidation to perform.

`TILEDB_OK` on success, and `TILEDB_ERR` on error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_array_consolidate_with_key (tiledb_ctx_t *ctx, const char *array_uri, tiledb_encryption_type_t encryption_type, const void *encryption_key, uint32_t key_length, tiledb_config_t *config) tiledb_array_consolidate_with_key tiledb_ctx_t * ctx const char * array_uri tiledb_encryption_type_t encryption_type const void * encryption_key uint32_t key_length tiledb_config_t * config

Depending on the consoliation mode in the config, consolidates either the fragment files, fragment metadata files, or array metadata files into a single file.

You must first finalize all queries to the array before consolidation can begin (as consolidation temporarily acquires an exclusive lock on the array).

Example:

    uint8_tkey[32]=...;
    tiledb_array_consolidate_with_key(
    ctx,"hdfs:///tiledb_arrays/my_array",
    TILEDB_AES_256_GCM,key,sizeof(key),nullptr);

ctx

The TileDB context.

array_uri

The name of the TileDB array to be consolidated.

encryption_type

The encryption type to use.

encryption_key

The encryption key to use.

key_length

Length in bytes of the encryption key.

config

Configuration parameters for the consolidation (`nullptr` means default, which will use the config from `ctx`). The `sm.consolidation.mode` parameter determines which type of consolidation to perform.

`TILEDB_OK` on success, and `TILEDB_ERR` on error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_vacuum (tiledb_ctx_t *ctx, const char *array_uri, tiledb_config_t *config) tiledb_array_vacuum tiledb_ctx_t * ctx const char * array_uri tiledb_config_t * config

Cleans up the array, such as consolidated fragments and array metadata. Note that this will coarsen the granularity of time traveling (see docs for more information).

Example:

    tiledb_array_vacuum(ctx,"hdfs:///tiledb_arrays/my_array");

ctx

The TileDB context.

array_uri

The name of the TileDB array to vacuum.

config

Configuration parameters for the vacuuming (`nullptr` means default, which will use the config from `ctx`).

`TILEDB_OK` on success, and `TILEDB_ERR` on error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_non_empty_domain (tiledb_ctx_t *ctx, tiledb_array_t *array, void *domain, int32_t *is_empty) tiledb_array_get_non_empty_domain tiledb_ctx_t * ctx tiledb_array_t * array void * domain int32_t * is_empty

Retrieves the non-empty domain from an array. This is the union of the non-empty domains of the array fragments.

Example:

    uint64_tdomain[4];//Assuminga2Darray,2[low,high]pairs
    int32_tis_empty;
    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    tiledb_array_get_non_empty_domain(ctx,array,domain,&is_empty);

ctx

The TileDB context

array

The array object (must be opened beforehand).

domain

The domain to be retrieved.

is_empty

The function sets it to `1` if the non-empty domain is empty (i.e., the array does not contain any data yet), and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_non_empty_domain_from_index (tiledb_ctx_t *ctx, tiledb_array_t *array, uint32_t idx, void *domain, int32_t *is_empty) tiledb_array_get_non_empty_domain_from_index tiledb_ctx_t * ctx tiledb_array_t * array uint32_t idx void * domain int32_t * is_empty

Retrieves the non-empty domain from an array for a given dimension index. This is the union of the non-empty domains of the array fragments on the given dimension.

Example:

    uint64_tdomain[2];
    int32_tis_empty;
    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    tiledb_array_get_non_empty_domain_from_index(ctx,array,0,domain,
    &is_empty);

ctx

The TileDB context

array

The array object (must be opened beforehand).

idx

The dimension index, following the order as it was defined in the domain of the array schema.

domain

The domain to be retrieved.

is_empty

The function sets it to `1` if the non-empty domain is empty (i.e., the array does not contain any data yet), and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_non_empty_domain_from_name (tiledb_ctx_t *ctx, tiledb_array_t *array, const char *name, void *domain, int32_t *is_empty) tiledb_array_get_non_empty_domain_from_name tiledb_ctx_t * ctx tiledb_array_t * array const char * name void * domain int32_t * is_empty

Retrieves the non-empty domain from an array for a given dimension name. This is the union of the non-empty domains of the array fragments on the given dimension.

Example:

    uint64_tdomain[2];
    int32_tis_empty;
    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    tiledb_array_get_non_empty_domain_from_name(ctx,array,"d1",domain,
    &is_empty);

ctx

The TileDB context

array

The array object (must be opened beforehand).

name

The dimension name.

domain

The domain to be retrieved.

is_empty

The function sets it to `1` if the non-empty domain is empty (i.e., the array does not contain any data yet), and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_non_empty_domain_var_size_from_index (tiledb_ctx_t *ctx, tiledb_array_t *array, uint32_t idx, uint64_t *start_size, uint64_t *end_size, int32_t *is_empty) tiledb_array_get_non_empty_domain_var_size_from_index tiledb_ctx_t * ctx tiledb_array_t * array uint32_t idx uint64_t * start_size uint64_t * end_size int32_t * is_empty

Retrieves the non-empty domain range sizes from an array for a given dimension index. This is the union of the non-empty domains of the array fragments on the given dimension. Applicable only to var-sized dimensions.

Example:

    int32_tis_empty;
    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    uint64_tstart_size,end_size;
    tiledb_array_get_non_empty_domain_var_size_from_index(
    ctx,array,0,&start_size,&end_size,&is_empty);
    //Ifnon-emptydomainrangeis`[aa,dddd]`,then`start_size=2`
    //and`end_size=4`.

ctx

The TileDB context

array

The array object (must be opened beforehand).

idx

The dimension index, following the order as it was defined in the domain of the array schema.

start_size

The size in bytes of the start range.

end_size

The size in bytes of the end range.

is_empty

The function sets it to `1` if the non-empty domain is empty (i.e., the array does not contain any data yet), and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_non_empty_domain_var_size_from_name (tiledb_ctx_t *ctx, tiledb_array_t *array, const char *name, uint64_t *start_size, uint64_t *end_size, int32_t *is_empty) tiledb_array_get_non_empty_domain_var_size_from_name tiledb_ctx_t * ctx tiledb_array_t * array const char * name uint64_t * start_size uint64_t * end_size int32_t * is_empty

Retrieves the non-empty domain range sizes from an array for a given dimension name. This is the union of the non-empty domains of the array fragments on the given dimension. Applicable only to var-sized dimensions.

Example:

    int32_tis_empty;
    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);
    uint64_tstart_size,end_size;
    tiledb_array_get_non_empty_domain_var_size_from_name(
    ctx,array,"d",&start_size,&end_size,&is_empty);
    //Ifnon-emptydomainrangeis`[aa,dddd]`,then`start_size=2`
    //and`end_size=4`.

ctx

The TileDB context

array

The array object (must be opened beforehand).

name

The dimension name.

start_size

The size in bytes of the start range.

end_size

The size in bytes of the end range.

is_empty

The function sets it to `1` if the non-empty domain is empty (i.e., the array does not contain any data yet), and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_non_empty_domain_var_from_index (tiledb_ctx_t *ctx, tiledb_array_t *array, uint32_t idx, void *start, void *end, int32_t *is_empty) tiledb_array_get_non_empty_domain_var_from_index tiledb_ctx_t * ctx tiledb_array_t * array uint32_t idx void * start void * end int32_t * is_empty

Retrieves the non-empty domain from an array for a given dimension index. This is the union of the non-empty domains of the array fragments on the given dimension. Applicable only to var-sized dimensions.

Example:

    int32_tis_empty;
    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);

    //Getrangesizesfirst
    uint64_tstart_size,end_size;
    tiledb_array_get_non_empty_domain_var_size_from_index(
    ctx,array,0,&start_size,&end_size,&is_empty);

    //Getdomain
    charstart[start_size];
    charend[end_size];
    tiledb_array_get_non_empty_domain_var_from_index(
    ctx,array,0,start,end,&is_empty);

ctx

The TileDB context

array

The array object (must be opened beforehand).

idx

The dimension index, following the order as it was defined in the domain of the array schema.

start

The domain range start to set.

end

The domain range end to set.

is_empty

The function sets it to `1` if the non-empty domain is empty (i.e., the array does not contain any data yet), and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_non_empty_domain_var_from_name (tiledb_ctx_t *ctx, tiledb_array_t *array, const char *name, void *start, void *end, int32_t *is_empty) tiledb_array_get_non_empty_domain_var_from_name tiledb_ctx_t * ctx tiledb_array_t * array const char * name void * start void * end int32_t * is_empty

Retrieves the non-empty domain from an array for a given dimension name. This is the union of the non-empty domains of the array fragments on the given dimension. Applicable only to var-sized dimensions.

Example:

    uint64_tdomain[2];
    int32_tis_empty;
    tiledb_array_t*array;
    tiledb_array_alloc(ctx,"my_array",&array);
    tiledb_array_open(ctx,array,TILEDB_READ);

    //Getrangesizesfirst
    uint64_tstart_size,end_size;
    tiledb_array_get_non_empty_domain_var_size_from_name(
    ctx,array,"d",&start_size,&end_size,&is_empty);

    //Getdomain
    charstart[start_size];
    charend[end_size];
    tiledb_array_get_non_empty_domain_var_from_name(
    ctx,array,"d",start,end,&is_empty);

ctx

The TileDB context

array

The array object (must be opened beforehand).

name

The dimension name.

start

The domain range start to set.

end

The domain range end to set.

is_empty

The function sets it to `1` if the non-empty domain is empty (i.e., the array does not contain any data yet), and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_uri (tiledb_ctx_t *ctx, tiledb_array_t *array, const char **array_uri) tiledb_array_get_uri tiledb_ctx_t * ctx tiledb_array_t * array const char ** array_uri

Retrieves the URI the array was opened with. It outputs an error if the array is not open.

ctx

The TileDB context.

array

The input array.

array_uri

The array URI to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_encryption_type (tiledb_ctx_t *ctx, const char *array_uri, tiledb_encryption_type_t *encryption_type) tiledb_array_encryption_type tiledb_ctx_t * ctx const char * array_uri tiledb_encryption_type_t * encryption_type

Retrieves the encryption type the array at the given URI was created with.

ctx

The TileDB context.

array_uri

The array URI.

encryption_type

The array encryption type to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_put_metadata (tiledb_ctx_t *ctx, tiledb_array_t *array, const char *key, tiledb_datatype_t value_type, uint32_t value_num, const void *value) tiledb_array_put_metadata tiledb_ctx_t * ctx tiledb_array_t * array const char * key tiledb_datatype_t value_type uint32_t value_num const void * value

It puts a metadata key-value item to an open array. The array must be opened in WRITE mode, otherwise the function will error out.

ctx

The TileDB context.

array

An array opened in WRITE mode.

key

The key of the metadata item to be added. UTF-8 encodings are acceptable.

value_type

The datatype of the value.

value_num

The value may consist of more than one items of the same datatype. This argument indicates the number of items in the value component of the metadata.

value

The metadata value in binary form.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

The writes will take effect only upon closing the array.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_delete_metadata (tiledb_ctx_t *ctx, tiledb_array_t *array, const char *key) tiledb_array_delete_metadata tiledb_ctx_t * ctx tiledb_array_t * array const char * key

It deletes a metadata key-value item from an open array. The array must be opened in WRITE mode, otherwise the function will error out.

ctx

The TileDB context.

array

An array opened in WRITE mode.

key

The key of the metadata item to be deleted.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

The writes will take effect only upon closing the array.

If the key does not exist, this will take no effect (i.e., the function will not error out).

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_metadata (tiledb_ctx_t *ctx, tiledb_array_t *array, const char *key, tiledb_datatype_t *value_type, uint32_t *value_num, const void **value) tiledb_array_get_metadata tiledb_ctx_t * ctx tiledb_array_t * array const char * key tiledb_datatype_t * value_type uint32_t * value_num const void ** value

It gets a metadata key-value item from an open array. The array must be opened in READ mode, otherwise the function will error out.

ctx

The TileDB context.

array

An array opened in READ mode.

key

The key of the metadata item to be retrieved. UTF-8 encodings are acceptable.

value_type

The datatype of the value.

value_num

The value may consist of more than one items of the same datatype. This argument indicates the number of items in the value component of the metadata. Keys with empty values are indicated by value_num == 1 and value == NULL.

value

The metadata value in binary form.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

If the key does not exist, then `value` will be NULL.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_metadata_num (tiledb_ctx_t *ctx, tiledb_array_t *array, uint64_t *num) tiledb_array_get_metadata_num tiledb_ctx_t * ctx tiledb_array_t * array uint64_t * num

It gets then number of metadata items in an open array. The array must be opened in READ mode, otherwise the function will error out.

ctx

The TileDB context.

array

An array opened in READ mode.

num

The number of metadata items to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_get_metadata_from_index (tiledb_ctx_t *ctx, tiledb_array_t *array, uint64_t index, const char **key, uint32_t *key_len, tiledb_datatype_t *value_type, uint32_t *value_num, const void **value) tiledb_array_get_metadata_from_index tiledb_ctx_t * ctx tiledb_array_t * array uint64_t index const char ** key uint32_t * key_len tiledb_datatype_t * value_type uint32_t * value_num const void ** value

It gets a metadata item from an open array using an index. The array must be opened in READ mode, otherwise the function will error out.

ctx

The TileDB context.

array

An array opened in READ mode.

index

The index used to get the metadata.

key

The metadata key.

key_len

The metadata key length.

value_type

The datatype of the value.

value_num

The value may consist of more than one items of the same datatype. This argument indicates the number of items in the value component of the metadata.

value

The metadata value in binary form.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_array_has_metadata_key (tiledb_ctx_t *ctx, tiledb_array_t *array, const char *key, tiledb_datatype_t *value_type, int32_t *has_key) tiledb_array_has_metadata_key tiledb_ctx_t * ctx tiledb_array_t * array const char * key tiledb_datatype_t * value_type int32_t * has_key

Checks whether a key exists in metadata from an open array. The array must be opened in READ mode, otherwise the function will error out.

ctx

The TileDB context.

array

An array opened in READ mode.

key

The key to be checked. UTF-8 encoding are acceptable.

value_type

The datatype of the value, if any.

has_key

Set to `1` if the metadata with given key exists, else `0`.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

If the key does not exist, then `value` will be NULL.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_array_consolidate_metadata (tiledb_ctx_t *ctx, const char *array_uri, tiledb_config_t *config) tiledb_array_consolidate_metadata tiledb_ctx_t * ctx const char * array_uri tiledb_config_t * config

Consolidates the array metadata into a single array metadata file.

You must first finalize all queries to the array before consolidation can begin (as consolidation temporarily acquires an exclusive lock on the array).

Example:

    tiledb_array_consolidate_metadata(
    ctx,"hdfs:///tiledb_arrays/my_array",nullptr);

ctx

The TileDB context.

array_uri

The name of the TileDB array whose metadata will be consolidated.

config

Configuration parameters for the consolidation (`nullptr` means default, which will use the config from `ctx`).

`TILEDB_OK` on success, and `TILEDB_ERR` on error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_array_consolidate_metadata_with_key (tiledb_ctx_t *ctx, const char *array_uri, tiledb_encryption_type_t encryption_type, const void *encryption_key, uint32_t key_length, tiledb_config_t *config) tiledb_array_consolidate_metadata_with_key tiledb_ctx_t * ctx const char * array_uri tiledb_encryption_type_t encryption_type const void * encryption_key uint32_t key_length tiledb_config_t * config

Consolidates the array metadata of an encrypted array into a single file.

You must first finalize all queries to the array before consolidation can begin (as consolidation temporarily acquires an exclusive lock on the array).

Example:

    uint8_tkey[32]=...;
    tiledb_array_consolidate_metadata_with_key(
    ctx,"hdfs:///tiledb_arrays/my_array",
    TILEDB_AES_256_GCM,key,sizeof(key),nullptr);

ctx

The TileDB context.

array_uri

The name of the TileDB array to be consolidated.

encryption_type

The encryption type to use.

encryption_key

The encryption key to use.

key_length

Length in bytes of the encryption key.

config

Configuration parameters for the consolidation (`nullptr` means default, which will use the config from `ctx`).

`TILEDB_OK` on success, and `TILEDB_ERR` on error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_object_type (tiledb_ctx_t *ctx, const char *path, tiledb_object_t *type) tiledb_object_type tiledb_ctx_t * ctx const char * path tiledb_object_t * type

Returns the TileDB object type for a given resource path.

Example:

    tiledb_object_ttype;
    tiledb_object_type(ctx,"arrays/my_array",&type);

ctx

The TileDB context.

path

The URI path to the TileDB resource.

type

The type to be retrieved.

`TILEDB_OK` on success, `TILEDB_ERR` on error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_object_remove (tiledb_ctx_t *ctx, const char *path) tiledb_object_remove tiledb_ctx_t * ctx const char * path

Deletes a TileDB resource (group, array, key-value).

Example:

    tiledb_object_remove(ctx,"arrays/my_array");

ctx

The TileDB context.

path

The URI path to the tiledb resource.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_object_move (tiledb_ctx_t *ctx, const char *old_path, const char *new_path) tiledb_object_move tiledb_ctx_t * ctx const char * old_path const char * new_path

Moves a TileDB resource (group, array, key-value).

Example:

    tiledb_object_move(ctx,"arrays/my_array","arrays/my_array_2");

ctx

The TileDB context.

old_path

The old TileDB directory.

new_path

The new TileDB directory.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_object_walk (tiledb_ctx_t *ctx, const char *path, tiledb_walk_order_t order, int32_t(*callback)(const char *, tiledb_object_t, void *), void *data) tiledb_object_walk tiledb_ctx_t * ctx const char * path tiledb_walk_order_t order int32_t(*)(const char *, tiledb_object_t, void *) callback void * data

Walks (iterates) over the TileDB objects contained in path. The traversal is done recursively in the order defined by the user. The user provides a callback function which is applied on each of the visited TileDB objects. The iteration continues for as long the callback returns non-zero, and stops when the callback returns 0. Note that this function ignores any object (e.g., file or directory) that is not TileDB-related.

Example:

    tiledb_object_walk(ctx,"arrays",TILEDB_PREORDER,NULL,NULL);

ctx

The TileDB context.

path

The path in which the traversal will occur.

order

The order of the recursive traversal (e.g., pre-order or post-order.

callback

The callback function to be applied on every visited object. The callback should return `0` if the iteration must stop, and `1` if the iteration must continue. It takes as input the currently visited path, the type of that path (e.g., array or group), and the data provided by the user for the callback. The callback returns `-1` upon error. Note that `path` in the callback will be an absolute path.

data

The data passed in the callback as the last argument.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_object_ls (tiledb_ctx_t *ctx, const char *path, int32_t(*callback)(const char *, tiledb_object_t, void *), void *data) tiledb_object_ls tiledb_ctx_t * ctx const char * path int32_t(*)(const char *, tiledb_object_t, void *) callback void * data

Similar to `tiledb_walk`, but now the function visits only the children of `path` (i.e., it does not recursively continue to the children directories).

Example:

    tiledb_object_ls(ctx,"arrays",NULL,NULL);

ctx

The TileDB context.

path

The path in which the traversal will occur.

callback

The callback function to be applied on every visited object. The callback should return `0` if the iteration must stop, and `1` if the iteration must continue. It takes as input the currently visited path, the type of that path (e.g., array or group), and the data provided by the user for the callback. The callback returns `-1` upon error. Note that `path` in the callback will be an absolute path.

data

The data passed in the callback as the last argument.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_alloc (tiledb_ctx_t *ctx, tiledb_config_t *config, tiledb_vfs_t **vfs) tiledb_vfs_alloc tiledb_ctx_t * ctx tiledb_config_t * config tiledb_vfs_t ** vfs

Creates a virtual filesystem object.

Example:

    tiledb_vfs_t*vfs;
    tiledb_vfs_alloc(ctx,config,&vfs);

ctx

The TileDB context.

vfs

The virtual filesystem object to be created.

config

Configuration parameters.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_vfs_free (tiledb_vfs_t **vfs) tiledb_vfs_free tiledb_vfs_t ** vfs

Frees a virtual filesystem object.

Example:

    tiledb_vfs_free(&vfs);

vfs

The virtual filesystem object to be freed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_get_config (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, tiledb_config_t **config) tiledb_vfs_get_config tiledb_ctx_t * ctx tiledb_vfs_t * vfs tiledb_config_t ** config

Retrieves the config from a VFS context.

Example:

    tiledb_config_t*config;
    tiledb_vfs_get_config(ctx,vfs,&config);
    //Makesuretofreetheretrievedconfig

ctx

The TileDB context.

vfs

The VFS object.

config

The config to be retrieved.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_create_bucket (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri) tiledb_vfs_create_bucket tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri

Creates an object-store bucket.

Example:

    tiledb_vfs_create_bucket(ctx,vfs,"s3://tiledb");

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the bucket to be created.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_remove_bucket (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri) tiledb_vfs_remove_bucket tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri

Deletes an object-store bucket.

Example:

    tiledb_vfs_delete_bucket(ctx,vfs,"s3://tiledb");

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the bucket to be deleted.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_empty_bucket (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri) tiledb_vfs_empty_bucket tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri

Deletes the contents of an object-store bucket.

Example:

    tiledb_vfs_empty_bucket(ctx,vfs,"s3://tiledb");

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the bucket to be emptied.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_is_empty_bucket (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri, int32_t *is_empty) tiledb_vfs_is_empty_bucket tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri int32_t * is_empty

Checks if an object-store bucket is empty.

Example:

    int32_tis_empty;
    tiledb_vfs_is_empty_bucket(ctx,vfs,"s3://tiledb",&empty);

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the bucket.

is_empty

Sets it to `1` if the input bucket is empty, and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_is_bucket (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri, int32_t *is_bucket) tiledb_vfs_is_bucket tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri int32_t * is_bucket

Checks if an object-store bucket exists.

Example:

    int32_texists;
    tiledb_vfs_is_bucket(ctx,vfs,"s3://tiledb",&exists);

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the bucket.

is_bucket

Sets it to `1` if the input URI is a bucket, and `0` otherwise.

TILEDB_OK for success and TILEDB_ERR for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_create_dir (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri) tiledb_vfs_create_dir tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri

Creates a directory.

- On S3, this is a noop.

- On all other backends, if the directory exists, the function just succeeds without doing anything.

Example:

    tiledb_vfs_create_dir(ctx,vfs,"hdfs:///temp/my_dir");

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the directory to be created.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_is_dir (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri, int32_t *is_dir) tiledb_vfs_is_dir tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri int32_t * is_dir

Checks if a directory exists.

Example:

    int32_texists;
    tiledb_vfs_is_dir(ctx,vfs,"hdfs:///temp/my_dir",&exists);

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the directory.

is_dir

Sets it to `1` if the directory exists and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

For S3, this function will return `true` if there is an object with prefix `uri/` (TileDB will append `/` internally to `uri` only if it does not exist), and `false` othewise.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_remove_dir (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri) tiledb_vfs_remove_dir tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri

Removes a directory (recursively).

Example:

    tiledb_vfs_remove_dir(ctx,vfs,"hdfs:///temp/my_dir");

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The uri of the directory to be removed

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_is_file (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri, int32_t *is_file) tiledb_vfs_is_file tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri int32_t * is_file

Checks if a file exists.

Example:

    int32_texists;
    tiledb_vfs_is_file(ctx,vfs,"hdfs:///temp/my_file",&is_file);

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the file.

is_file

Sets it to `1` if the file exists and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_remove_file (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri) tiledb_vfs_remove_file tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri

Deletes a file.

Example:

    tiledb_vfs_remove_file(ctx,vfs,"hdfs:///temp/my_file");

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the file.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_dir_size (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri, uint64_t *size) tiledb_vfs_dir_size tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri uint64_t * size

Retrieves the size of a directory. This function is recursive, i.e., it will consider all files in the directory tree rooted at `uri`.

Example:

    uint64_tdir_size;
    tiledb_vfs_dir_size(ctx,vfs,"hdfs:///temp/my_dir",&dir_size);

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the directory.

size

The directory size to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_file_size (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri, uint64_t *size) tiledb_vfs_file_size tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri uint64_t * size

Retrieves the size of a file.

Example:

    uint64_tfile_size;
    tiledb_vfs_file_size(ctx,vfs,"hdfs:///temp/my_file",&file_size);

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the file.

size

The file size to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_move_file (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *old_uri, const char *new_uri) tiledb_vfs_move_file tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * old_uri const char * new_uri

Renames a file. If the destination file exists, it will be overwritten.

Example:

    tiledb_vfs_move_file(
    ctx,vfs,"hdfs:///temp/my_file","hdfs::///new_file");

ctx

The TileDB context.

vfs

The virtual filesystem object.

old_uri

The old URI.

new_uri

The new URI.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_move_dir (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *old_uri, const char *new_uri) tiledb_vfs_move_dir tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * old_uri const char * new_uri

Renames a directory.

Example:

    tiledb_vfs_move_dir(ctx,vfs,"hdfs:///temp/my_dir","hdfs::///new_dir");

ctx

The TileDB context.

vfs

The virtual filesystem object.

old_uri

The old URI.

new_uri

The new URI.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_copy_file (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *old_uri, const char *new_uri) tiledb_vfs_copy_file tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * old_uri const char * new_uri

Copies a file. If the destination file exists, it will be overwritten.

Example:

    tiledb_vfs_copy_file(
    ctx,vfs,"hdfs:///temp/my_file","hdfs::///new_file");

ctx

The TileDB context.

vfs

The virtual filesystem object.

old_uri

The old URI.

new_uri

The new URI.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_copy_dir (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *old_uri, const char *new_uri) tiledb_vfs_copy_dir tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * old_uri const char * new_uri

Copies a directory. If the destination directory exists, it will be overwritten.

Example:

    tiledb_vfs_copy_dir(
    ctx,vfs,"hdfs:///temp/my_dir","hdfs::///new_dir");

ctx

The TileDB context.

vfs

The virtual filesystem object.

old_uri

The old URI.

new_uri

The new URI.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_open (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri, tiledb_vfs_mode_t mode, tiledb_vfs_fh_t **fh) tiledb_vfs_open tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri tiledb_vfs_mode_t mode tiledb_vfs_fh_t ** fh

Prepares a file for reading/writing.

Example:

    tiledb_vfs_fh_t*fh;
    tiledb_vfs_open(ctx,vfs,"some_file",TILEDB_VFS_READ,&fh);
    //Makesuretocloseanddeletethecreatedfilehandle

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the file.

mode

The mode in which the file is opened:

- `TILEDB_VFS_READ`: The file is opened for reading. An error is returned if the file does not exist.

- `TILEDB_VFS_WRITE`: The file is opened for writing. If the file exists, it will be overwritten.

- `TILEDB_VFS_APPEND`: The file is opened for writing. If the file exists, the write will start from the end of the file. Note that S3 does not support this operation and, thus, an error will be thrown in that case.

fh

The file handle that is created. This will be used in `tiledb_vfs_read`, `tiledb_vfs_write` and `tiledb_vfs_sync`.

`TILEDB_OK` for success and `TILEDB_ERR` or `TILEDB_OOM` for error.

If the file is closed after being opened, without having written any data to it, the file will not be created. If you wish to create an empty file, use `tiledb_vfs_touch` instead.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_close (tiledb_ctx_t *ctx, tiledb_vfs_fh_t *fh) tiledb_vfs_close tiledb_ctx_t * ctx tiledb_vfs_fh_t * fh

Closes a file. This is flushes the buffered data into the file when the file was opened in write (or append) mode. It is particularly important to be called after S3 writes, as otherwise the writes will not take effect.

Example:

    tiledb_vfs_close(ctx,vfs,fh);

ctx

The TileDB context.

fh

The file handle.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_read (tiledb_ctx_t *ctx, tiledb_vfs_fh_t *fh, uint64_t offset, void *buffer, uint64_t nbytes) tiledb_vfs_read tiledb_ctx_t * ctx tiledb_vfs_fh_t * fh uint64_t offset void * buffer uint64_t nbytes

Reads from a file.

Example:

    charbuffer[10000];
    tiledb_vfs_read(ctx,fh,100,buffer,10000);

ctx

The TileDB context.

fh

The URI file handle.

offset

The offset in the file where the read begins.

buffer

The buffer to read into.

nbytes

Number of bytes to read.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_write (tiledb_ctx_t *ctx, tiledb_vfs_fh_t *fh, const void *buffer, uint64_t nbytes) tiledb_vfs_write tiledb_ctx_t * ctx tiledb_vfs_fh_t * fh const void * buffer uint64_t nbytes

Writes the contents of a buffer into a file. Note that this function only appends data at the end of the file. If the file does not exist, it will be created.

Example:

    constchar*msg="Thiswillbewrittentothefile";
    tiledb_vfs_write(ctx,fh,buffer,strlen(msg));

ctx

The TileDB context.

fh

The URI file handle.

buffer

The buffer to write from.

nbytes

Number of bytes to write.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_sync (tiledb_ctx_t *ctx, tiledb_vfs_fh_t *fh) tiledb_vfs_sync tiledb_ctx_t * ctx tiledb_vfs_fh_t * fh

Syncs (flushes) a file.

Example:

    tiledb_vfs_sync(ctx,fh);

ctx

The TileDB context.

fh

The URI file handle.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

This has no effect for S3.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_ls (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *path, int32_t(*callback)(const char *, void *), void *data) tiledb_vfs_ls tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * path int32_t(*)(const char *, void *) callback void * data

The function visits only the children of `path` (i.e., it does not recursively continue to the children directories) and applies the `callback` function using the input `data`.

Example:

    tiledb_vfs_ls(ctx,vfs,"my_dir",NULL,NULL);

ctx

The TileDB context.

vfs

The virtual filesystem object.

path

The path in which the traversal will occur.

callback

The callback function to be applied on every visited object. The callback should return `0` if the iteration must stop, and `1` if the iteration must continue. It takes as input the currently visited path, the type of that path (e.g., array or group), and the data provided by the user for the callback. The callback returns `-1` upon error. Note that `path` in the callback will be an absolute path.

data

The data passed in the callback as the last argument.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_vfs_fh_free (tiledb_vfs_fh_t **fh) tiledb_vfs_fh_free tiledb_vfs_fh_t ** fh

Frees a file handle.

Example:

    tiledb_vfs_fh_free(&fh);

fh

The URI file handle.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_fh_is_closed (tiledb_ctx_t *ctx, tiledb_vfs_fh_t *fh, int32_t *is_closed) tiledb_vfs_fh_is_closed tiledb_ctx_t * ctx tiledb_vfs_fh_t * fh int32_t * is_closed

Checks if a file handle is closed.

Example:

    int32_tis_closed;
    tiledb_vfs_fh_is_closed(ctx,fh,&is_closed);

ctx

The TileDB context.

fh

The URI file handle.

is_closed

Set to `1` if the file handle is closed, and `0` otherwise.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_vfs_touch (tiledb_ctx_t *ctx, tiledb_vfs_t *vfs, const char *uri) tiledb_vfs_touch tiledb_ctx_t * ctx tiledb_vfs_t * vfs const char * uri

Touches a file, i.e., creates a new empty file.

Example:

    tiledb_vfs_touch(ctx,vfs,"my_empty_file");

ctx

The TileDB context.

vfs

The virtual filesystem object.

uri

The URI of the file to be created.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_uri_to_path (tiledb_ctx_t *ctx, const char *uri, char *path_out, uint32_t *path_length) tiledb_uri_to_path tiledb_ctx_t * ctx const char * uri char * path_out uint32_t * path_length

Converts the given file URI to a null-terminated platform-native file path.

Example:

    charpath[TILEDB_MAX_PATH];
    uint32_tlength=TILEDB_MAX_PATH;//Mustbesettonon-zero
    tiledb_uri_to_path(ctx,"file:///my_array",path,&length);
    //Thiswillset"my_array"to`path`

ctx

The TileDB context.

uri

The URI to be converted.

path_out

The buffer where the converted path string is stored.

path_length

The length of the path buffer. On return, this is set to the length of the converted path string, or 0 on error.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

The path_out buffer must be allocated according to the platform's maximum path length (e.g. `TILEDB_MAX_PATH), which includes space for the terminating null character.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_stats_enable (void) tiledb_stats_enable void

Enable internal statistics gathering.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_stats_disable (void) tiledb_stats_disable void

Disable internal statistics gathering.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_stats_reset (void) tiledb_stats_reset void

Reset all internal statistics counters to 0.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_stats_dump (FILE *out) tiledb_stats_dump FILE * out

Dump all internal statistics counters to some output (e.g., file or stdout).

out

The output.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_stats_dump_str (char **out) tiledb_stats_dump_str char ** out

Dump all internal statistics counters to an output string. The caller is responsible for freeing the resulting string.

Example:

    char*stats_str;
    tiledb_stats_dump_str(&stats_str);
    //...
    tiledb_stats_free_str(&stats_str);

out

Will be set to point to an allocated string containing the stats.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_stats_raw_dump (FILE *out) tiledb_stats_raw_dump FILE * out

Dump all raw internal statistics counters to some output (e.g., file or stdout) as a JSON.

out

The output.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_stats_raw_dump_str (char **out) tiledb_stats_raw_dump_str char ** out

Dump all raw internal statistics counters to a JSON-formatted output string. The caller is responsible for freeing the resulting string.

Example:

    char*stats_str;
    tiledb_stats_raw_dump_str(&stats_str);
    //...
    tiledb_stats_raw_free_str(&stats_str);

out

Will be set to point to an allocated string containing the stats.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_stats_free_str (char **out) tiledb_stats_free_str char ** out

Free the memory associated with a previously dumped stats string.

out

Pointer to a previously allocated stats string.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_heap_profiler_enable (const char *file_name_prefix, uint64_t dump_interval_ms, uint64_t dump_interval_bytes, uint64_t dump_threshold_bytes) tiledb_heap_profiler_enable const char * file_name_prefix uint64_t dump_interval_ms uint64_t dump_interval_bytes uint64_t dump_threshold_bytes

Enable heap profiling.

file_name_prefix

If empty or null, stats are dumped to stdout. If non-empty, this specifies the file_name prefix to write to. For example, value "tiledb_mem_stats" will write to "tiledb_mem_stats__1611170501", where the postfix is determined by the current epoch.

dump_interval_ms

If non-zero, this spawns a dedicated thread to dump on this time interval.

dump_interval_bytes

If non-zero, a dump will occur when the total number of lifetime allocated bytes is increased by more than this amount.

dump_threshold_bytes

If non-zero, labeled allocations with a number of bytes lower than this threshold will not be reported in the dump.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_alloc (tiledb_ctx_t *ctx, const char *array_uri, tiledb_fragment_info_t **fragment_info) tiledb_fragment_info_alloc tiledb_ctx_t * ctx const char * array_uri tiledb_fragment_info_t ** fragment_info

Creates a fragment info object for a given array, and fetches all the fragment information for that array.

Example:

    tiledb_fragment_info*fragment_info;
    tiledb_fragment_info_alloc(ctx,"array_uri",&fragment_info);

ctx

The TileDB context.

array_uri

The array URI.

fragment_info

The fragment info object to be created and populated.

`TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.

TILEDB_EXPORT void TILEDB_EXPORT void tiledb_fragment_info_free (tiledb_fragment_info_t **fragment_info) tiledb_fragment_info_free tiledb_fragment_info_t ** fragment_info

Frees a fragment info object.

Example:

    tiledb_fragment_info_free(&fragment_info);

fragment_info

The fragment info object to be freed.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_load (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info) tiledb_fragment_info_load tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info

Loads the fragment info.

Example:

    tiledb_fragment_info_load(ctx,fragment_info);

ctx

The TileDB context.

fragment_info

The fragment info object.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_DEPRECATED_EXPORT int32_t TILEDB_DEPRECATED_EXPORT int32_t tiledb_fragment_info_load_with_key (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, tiledb_encryption_type_t encryption_type, const void *encryption_key, uint32_t key_length) tiledb_fragment_info_load_with_key tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info tiledb_encryption_type_t encryption_type const void * encryption_key uint32_t key_length

Loads the fragment info from an encrypted array.

Example:

    tiledb_fragment_info_load_with_key(
    ctx,fragment_info,TILEDB_AES_256_GCM,key,sizeof(key));

ctx

The TileDB context.

fragment_info

The fragment info object.

encryption_type

The encryption type to use.

encryption_key

The encryption key to use.

key_length

Length in bytes of the encryption key.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_fragment_num (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t *fragment_num) tiledb_fragment_info_get_fragment_num tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t * fragment_num

Gets the number of fragments.

Example:

    uint32_tfragment_num;
    tiledb_fragment_info_get_fragment_num(ctx,fragment_info,&fragment_num);

ctx

The TileDB context.

fragment_info

The fragment info object.

fragment_num

The number of fragments to retrieve.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_fragment_uri (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, const char **uri) tiledb_fragment_info_get_fragment_uri tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid const char ** uri

Gets a fragment URI.

Example:

    constchar*uri;
    tiledb_fragment_info_get_fragment_uri(ctx,fragment_info,1,&uri);

ctx

The TileDB context.

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

uri

The fragment URI to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_fragment_size (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint64_t *size) tiledb_fragment_info_get_fragment_size tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint64_t * size

Gets the fragment size in bytes.

Example:

    uint64_tsize;
    tiledb_fragment_info_get_fragment_size(ctx,fragment_info,1,&size);

ctx

The TileDB context.

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

size

The fragment size to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_dense (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, int32_t *dense) tiledb_fragment_info_get_dense tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid int32_t * dense

Checks if a fragment is dense.

Example:

    int32_tdense;
    tiledb_fragment_info_get_dense(ctx,fragment_info,1,&dense);

ctx

The TileDB context.

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

dense

`1` if the fragment is dense.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_sparse (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, int32_t *sparse) tiledb_fragment_info_get_sparse tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid int32_t * sparse

Checks if a fragment is sparse.

Example:

    int32_tsparse;
    tiledb_fragment_info_get_sparse(ctx,fragment_info,1,&sparse);

ctx

The TileDB context.

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

sparse

`1` if the fragment is sparse.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_timestamp_range (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint64_t *start, uint64_t *end) tiledb_fragment_info_get_timestamp_range tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint64_t * start uint64_t * end

Gets the timestamp range of a fragment.

Example:

    uint64_tstart,end;
    tiledb_fragment_info_get_timestamp_range(ctx,fragment_info,1,&start,
    &end);

ctx

The TileDB context.

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

start

The start of the timestamp range to be retrieved.

end

The end of the timestamp range to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_non_empty_domain_from_index (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint32_t did, void *domain) tiledb_fragment_info_get_non_empty_domain_from_index tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint32_t did void * domain

Retrieves the non-empty domain from a given fragment for a given dimension index.

Example:

    uint64_tdomain[2];
    tiledb_fragment_info_get_non_empty_domain_from_index(
    ctx,fragment_info,0,0,domain);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

did

The dimension index, following the order as it was defined in the domain of the array schema.

domain

The domain to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_non_empty_domain_from_name (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, const char *dim_name, void *domain) tiledb_fragment_info_get_non_empty_domain_from_name tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid const char * dim_name void * domain

Retrieves the non-empty domain from a given fragment for a given dimension name.

Example:

    uint64_tdomain[2];
    tiledb_fragment_info_get_non_empty_domain_from_name(
    ctx,fragment_info,0,"d1",domain);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

dim_name

The dimension name.

domain

The domain to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_non_empty_domain_var_size_from_index (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint32_t did, uint64_t *start_size, uint64_t *end_size) tiledb_fragment_info_get_non_empty_domain_var_size_from_index tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint32_t did uint64_t * start_size uint64_t * end_size

Retrieves the non-empty domain range sizes from a fragment for a given dimension index. Applicable to var-sized dimensions.

Example:

    uint64_tstart_size,end_size;
    tiledb_fragment_info_get_non_empty_domain_var_size_from_index(
    ctx,fragment_info,0,&start_size,&end_size);
    //Ifnon-emptydomainrangeis`[aa,dddd]`,then`start_size=2`
    //and`end_size=4`.

ctx

The TileDB context

fragment_info

The fragment information object.

fid

The fragment index.

did

The dimension index, following the order as it was defined in the domain of the array schema.

start_size

The size in bytes of the start range.

end_size

The size in bytes of the end range.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_non_empty_domain_var_size_from_name (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, const char *dim_name, uint64_t *start_size, uint64_t *end_size) tiledb_fragment_info_get_non_empty_domain_var_size_from_name tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid const char * dim_name uint64_t * start_size uint64_t * end_size

Retrieves the non-empty domain range sizes from a fragment for a given dimension name. Applicable to var-sized dimensions.

Example:

    uint64_tstart_size,end_size;
    tiledb_fragment_info_get_non_empty_domain_var_size_from_name(
    ctx,fragment_info,"d",&start_size,&end_size);
    //Ifnon-emptydomainrangeis`[aa,dddd]`,then`start_size=2`
    //and`end_size=4`.

ctx

The TileDB context

fragment_info

The fragment information object.

fid

The fragment index.

dim_name

The dimension name.

start_size

The size in bytes of the start range.

end_size

The size in bytes of the end range.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_non_empty_domain_var_from_index (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint32_t did, void *start, void *end) tiledb_fragment_info_get_non_empty_domain_var_from_index tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint32_t did void * start void * end

Retrieves the non-empty domain from a fragment for a given dimension index. Applicable to var-sized dimensions.

Example:

    //Getrangesizesfirst
    uint64_tstart_size,end_size;
    tiledb_fragment_info_get_non_empty_domain_var_size_from_index(
    ctx,fragment_info,0,0,&start_size,&end_size);

    //Getdomain
    charstart[start_size];
    charend[end_size];
    tiledb_fragment_info_get_non_empty_domain_var_from_index(
    ctx,fragment_info,0,0,start,end);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The fragment index.

did

The dimension index, following the order as it was defined in the domain of the array schema.

start

The domain range start to set.

end

The domain range end to set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_non_empty_domain_var_from_name (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, const char *dim_name, void *start, void *end) tiledb_fragment_info_get_non_empty_domain_var_from_name tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid const char * dim_name void * start void * end

Retrieves the non-empty domain from a fragment for a given dimension name. Applicable to var-sized dimensions.

Example:

    //Getrangesizesfirst
    uint64_tstart_size,end_size;
    tiledb_fragment_info_get_non_empty_domain_var_size_from_name(
    ctx,fragment_info,0,"d",&start_size,&end_size);

    //Getdomain
    charstart[start_size];
    charend[end_size];
    tiledb_fragment_info_get_non_empty_domain_var_from_name(
    ctx,fragment_info,0,"d",start,end);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The fragment index.

dim_name

The dimension name.

start

The domain range start to set.

end

The domain range end to set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_mbr_num (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint64_t *mbr_num) tiledb_fragment_info_get_mbr_num tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint64_t * mbr_num

Retrieves the number of MBRs from the fragment.

In the case of sparse fragments, this is the number of physical tiles.

Dense fragments do not contain MBRs.

Example:

    uint64_tmbr_num;
    tiledb_fragment_info_get_mbr_num(ctx,fragment_info,0,&mbr_num);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

mbrs_num

The number of MBRs to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_mbr_from_index (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint32_t mid, uint32_t did, void *mbr) tiledb_fragment_info_get_mbr_from_index tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint32_t mid uint32_t did void * mbr

Retrieves the MBR from a given fragment for a given dimension index.

Example:

    uint64_tmbr[2];
    tiledb_fragment_info_get_mbr_from_index(ctx,fragment_info,0,0,0,mbr);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

mid

The mbr of the fragment of interest.

did

The dimension index, following the order as it was defined in the domain of the array schema.

mbr

The mbr to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_mbr_from_name (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint32_t mid, const char *dim_name, void *mbr) tiledb_fragment_info_get_mbr_from_name tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint32_t mid const char * dim_name void * mbr

Retrieves the MBR from a given fragment for a given dimension name.

Example:

    uint64_tmbr[2];
    tiledb_fragment_info_get_mbr_from_name(ctx,fragment_info,0,0,"d1",mbr);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

mid

The mbr of the fragment of interest.

dim_name

The dimension name.

mbr

The mbr to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_mbr_var_size_from_index (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint32_t mid, uint32_t did, uint64_t *start_size, uint64_t *end_size) tiledb_fragment_info_get_mbr_var_size_from_index tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint32_t mid uint32_t did uint64_t * start_size uint64_t * end_size

Retrieves the MBR sizes from a fragment for a given dimension index. Applicable to var-sized dimensions.

Example:

    uint64_tstart_size,end_size;
    tiledb_fragment_info_get_mbr_var_size_from_index(
    ctx,fragment_info,0,0,0,&start_size,&end_size);
    //Ifnon-emptydomainrangeis`[aa,dddd]`,then`start_size=2`
    //and`end_size=4`.

ctx

The TileDB context

fragment_info

The fragment information object.

fid

The fragment index.

mid

The mbr of the fragment of interest.

did

The dimension index, following the order as it was defined in the domain of the array schema.

start_size

The size in bytes of the start range.

end_size

The size in bytes of the end range.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_mbr_var_size_from_name (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint32_t mid, const char *dim_name, uint64_t *start_size, uint64_t *end_size) tiledb_fragment_info_get_mbr_var_size_from_name tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint32_t mid const char * dim_name uint64_t * start_size uint64_t * end_size

Retrieves the MBR range sizes from a fragment for a given dimension name. Applicable to var-sized dimensions.

Example:

    uint64_tstart_size,end_size;
    tiledb_fragment_info_get_mbr_var_size_from_name(
    ctx,fragment_info,0,0,"d1",&start_size,&end_size);
    //Ifnon-emptydomainrangeis`[aa,dddd]`,then`start_size=2`
    //and`end_size=4`.

ctx

The TileDB context

fragment_info

The fragment information object.

fid

The fragment index.

mid

The mbr of the fragment of interest.

dim_name

The dimension name.

start_size

The size in bytes of the start range.

end_size

The size in bytes of the end range.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_mbr_var_from_index (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint32_t mid, uint32_t did, void *start, void *end) tiledb_fragment_info_get_mbr_var_from_index tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint32_t mid uint32_t did void * start void * end

Retrieves the MBR from a fragment for a given dimension index. Applicable to var-sized dimensions.

Example:

    //Getrangesizesfirst
    uint64_tstart_size,end_size;
    tiledb_fragment_info_get_mbr_var_size_from_index(
    ctx,fragment_info,0,0,0,&start_size,&end_size);

    //Getdomain
    charstart[start_size];
    charend[end_size];
    tiledb_fragment_info_get_mbr_var_from_index(
    ctx,fragment_info,0,0,0,start,end);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The fragment index.

mid

The mbr of the fragment of interest.

did

The dimension index, following the order as it was defined in the domain of the array schema.

start

The domain range start to set.

end

The domain range end to set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_mbr_var_from_name (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint32_t mid, const char *dim_name, void *start, void *end) tiledb_fragment_info_get_mbr_var_from_name tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint32_t mid const char * dim_name void * start void * end

Retrieves the MBR from a fragment for a given dimension name. Applicable to var-sized dimensions.

Example:

    //Getrangesizesfirst
    uint64_tstart_size,end_size;
    tiledb_fragment_info_get_mbr_var_size_from_name(
    ctx,fragment_info,0,0,"d1",&start_size,&end_size);

    //Getdomain
    charstart[start_size];
    charend[end_size];
    tiledb_fragment_info_get_mbr_var_from_name(
    ctx,fragment_info,0,0,"d1",start,end);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The fragment index.

mid

The mbr of the fragment of interest.

dim_name

The dimension name.

start

The domain range start to set.

end

The domain range end to set.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_cell_num (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint64_t *cell_num) tiledb_fragment_info_get_cell_num tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint64_t * cell_num

Retrieves the number of cells written to the fragment by the user.

In the case of sparse fragments, this is the number of non-empty cells in the fragment.

In the case of dense fragments, TileDB may add fill values to populate partially populated tiles. Those fill values are counted in the returned number of cells. In other words, the cell number is derived from the number of integral tiles written in the file.

Example:

    uint64_tcell_num;
    tiledb_fragment_info_get_cell_num(ctx,fragment_info,0,&cell_num);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

cell_num

The number of cells to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_version (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, uint32_t *version) tiledb_fragment_info_get_version tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid uint32_t * version

Retrieves the format version of a fragment.

Example:

    uint32_tversion;
    tiledb_fragment_info_get_version(ctx,fragment_info,0,&version);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

version

The format version to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_has_consolidated_metadata (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, int32_t *has) tiledb_fragment_info_has_consolidated_metadata tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid int32_t * has

Checks if a fragment has consolidated metadata.

Example:

    int32_thas;
    tiledb_fragment_info_has_consolidated_metadata(ctx,fragment_info,0,&has);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

has

True if the fragment has consolidated metadata.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_unconsolidated_metadata_num (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t *unconsolidated) tiledb_fragment_info_get_unconsolidated_metadata_num tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t * unconsolidated

Gets the number of fragments with unconsolidated metadata.

Example:

    uint32_tunconsolidated;
    tiledb_fragment_info_get_unconsolidated_metadata_num(ctx,fragment_info,
    &unconsolidated);

ctx

The TileDB context

fragment_info

The fragment info object.

unconsolidated

The number of fragments with unconsolidated metadata.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_to_vacuum_num (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t *to_vacuum_num) tiledb_fragment_info_get_to_vacuum_num tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t * to_vacuum_num

Gets the number of fragments to vacuum.

Example:

    uint32_tto_vacuum_num;
    tiledb_fragment_info_get_to_vacuum_num(ctx,fragment_info,&to_vacuum_num);

ctx

The TileDB context

fragment_info

The fragment info object.

to_vacuum_num

The number of fragments to vacuum.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_to_vacuum_uri (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, const char **uri) tiledb_fragment_info_get_to_vacuum_uri tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid const char ** uri

Gets the URI of the fragment to vacuum with the given index.

Example:

    constchar*uri;
    tiledb_fragment_info_get_to_vacuum_uri(ctx,fragment_info,1,&uri);

ctx

The TileDB context.

fragment_info

The fragment info object.

fid

The index of the fragment to vacuum of interest.

uri

The fragment URI to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_array_schema (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, tiledb_array_schema_t **array_schema) tiledb_fragment_info_get_array_schema tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid tiledb_array_schema_t ** array_schema

Retrieves the array schema name a fragment.

Example:

    tiledb_array_schema_t*array_schema;
    tiledb_fragment_info_get_array_schema(ctx,fragment_info,0,&array_schema);

ctx

The TileDB context

fragment_info

The fragment info object.

fid

The index of the fragment of interest.

array_schema

The array schema to be retrieved.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_get_array_schema_name (tiledb_ctx_t *ctx, tiledb_fragment_info_t *fragment_info, uint32_t fid, const char **schema_name) tiledb_fragment_info_get_array_schema_name tiledb_ctx_t * ctx tiledb_fragment_info_t * fragment_info uint32_t fid const char ** schema_name

Get the fragment info schema name.

Example:

    char*name;
    tiledb_fragment_info_schema_name(ctx,fragment_info,&schema_name);

ctx

The TileDB context.

fragment_info

The fragment info object.

name

The schema name.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

TILEDB_EXPORT int32_t TILEDB_EXPORT int32_t tiledb_fragment_info_dump (tiledb_ctx_t *ctx, const tiledb_fragment_info_t *fragment_info, FILE *out) tiledb_fragment_info_dump tiledb_ctx_t * ctx const tiledb_fragment_info_t * fragment_info FILE * out

Dumps the fragment info in ASCII format in the selected output.

Example:

The following prints the fragment info dump in standard output.

    tiledb_fragment_info_dump(ctx,fragment_info,stdout);

ctx

The TileDB context.

fragment_info

The fragment info object.

out

The output.

`TILEDB_OK` for success and `TILEDB_ERR` for error.

# LICENSE

The MIT License

Copyright (c) 2017-2021 TileDB, Inc.

Copyright (c) 2016 MIT and Intel Corporation

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

# DESCRIPTION

This file declares the C API for TileDB.

    #ifndefTILEDB_H
    #defineTILEDB_H

    #include"tiledb_version.h"

    //GeneratedbyCMake;definesTILEDB_EXPORT(etc)macros.
    #include"tiledb_export.h"

    #include<stdint.h>
    #include<stdio.h>

    /***********************************/
    /*MACROS*/
    /***********************************/

    #ifdef__cplusplus
    extern"C"{
    #endif

    /********************************/
    /*TILEDBENUMS*/
    /********************************/

    typedefenum{
    #defineTILEDB_OBJECT_TYPE_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_OBJECT_TYPE_ENUM
    }tiledb_object_t;

    typedefenum{
    #defineTILEDB_QUERY_TYPE_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_QUERY_TYPE_ENUM
    }tiledb_query_type_t;

    typedefenum{
    #defineTILEDB_QUERY_STATUS_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_QUERY_STATUS_ENUM
    }tiledb_query_status_t;

    typedefenum{
    #defineTILEDB_QUERY_CONDITION_OP_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_QUERY_CONDITION_OP_ENUM
    }tiledb_query_condition_op_t;

    typedefenum{
    #defineTILEDB_QUERY_CONDITION_COMBINATION_OP_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_QUERY_CONDITION_COMBINATION_OP_ENUM
    }tiledb_query_condition_combination_op_t;

    typedefenum{
    #defineTILEDB_FILESYSTEM_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_FILESYSTEM_ENUM
    }tiledb_filesystem_t;

    typedefenum{
    #defineTILEDB_DATATYPE_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_DATATYPE_ENUM
    }tiledb_datatype_t;

    typedefenum{
    #defineTILEDB_ARRAY_TYPE_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_ARRAY_TYPE_ENUM
    }tiledb_array_type_t;

    typedefenum{
    #defineTILEDB_LAYOUT_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_LAYOUT_ENUM
    }tiledb_layout_t;

    typedefenum{
    #defineTILEDB_FILTER_TYPE_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_FILTER_TYPE_ENUM
    }tiledb_filter_type_t;

    typedefenum{
    #defineTILEDB_FILTER_OPTION_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_FILTER_OPTION_ENUM
    }tiledb_filter_option_t;

    typedefenum{
    #defineTILEDB_ENCRYPTION_TYPE_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_ENCRYPTION_TYPE_ENUM
    }tiledb_encryption_type_t;

    typedefenum{
    #defineTILEDB_WALK_ORDER_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_WALK_ORDER_ENUM
    }tiledb_walk_order_t;

    typedefenum{
    #defineTILEDB_VFS_MODE_ENUM(id)TILEDB_##id
    #include"tiledb_enum.h"
    #undefTILEDB_VFS_MODE_ENUM
    }tiledb_vfs_mode_t;

    /********************************/
    /*ENUMSTO/FROMSTR*/
    /********************************/

    TILEDB_EXPORTint32_t
    tiledb_query_type_to_str(tiledb_query_type_tquery_type,constchar**str);

    TILEDB_EXPORTint32_t
    tiledb_query_type_from_str(constchar*str,tiledb_query_type_t*query_type);

    TILEDB_EXPORTint32_t
    tiledb_object_type_to_str(tiledb_object_tobject_type,constchar**str);

    TILEDB_EXPORTint32_t
    tiledb_object_type_from_str(constchar*str,tiledb_object_t*object_type);

    TILEDB_EXPORTint32_t
    tiledb_filesystem_to_str(tiledb_filesystem_tfilesystem,constchar**str);

    TILEDB_EXPORTint32_t
    tiledb_filesystem_from_str(constchar*str,tiledb_filesystem_t*filesystem);

    TILEDB_EXPORTint32_t
    tiledb_datatype_to_str(tiledb_datatype_tdatatype,constchar**str);

    TILEDB_EXPORTint32_t
    tiledb_datatype_from_str(constchar*str,tiledb_datatype_t*datatype);

    TILEDB_EXPORTint32_t
    tiledb_array_type_to_str(tiledb_array_type_tarray_type,constchar**str);

    TILEDB_EXPORTint32_t
    tiledb_array_type_from_str(constchar*str,tiledb_array_type_t*array_type);

    TILEDB_EXPORTint32_t
    tiledb_layout_to_str(tiledb_layout_tlayout,constchar**str);

    TILEDB_EXPORTint32_t
    tiledb_layout_from_str(constchar*str,tiledb_layout_t*layout);

    TILEDB_EXPORTint32_t
    tiledb_filter_type_to_str(tiledb_filter_type_tfilter_type,constchar**str);

    TILEDB_EXPORTint32_t
    tiledb_filter_type_from_str(constchar*str,tiledb_filter_type_t*filter_type);

    TILEDB_EXPORTint32_ttiledb_filter_option_to_str(
    tiledb_filter_option_tfilter_option,constchar**str);

    TILEDB_EXPORTint32_ttiledb_filter_option_from_str(
    constchar*str,tiledb_filter_option_t*filter_option);

    TILEDB_EXPORTint32_ttiledb_encryption_type_to_str(
    tiledb_encryption_type_tencryption_type,constchar**str);

    TILEDB_EXPORTint32_ttiledb_encryption_type_from_str(
    constchar*str,tiledb_encryption_type_t*encryption_type);

    TILEDB_EXPORTint32_ttiledb_query_status_to_str(
    tiledb_query_status_tquery_status,constchar**str);

    TILEDB_EXPORTint32_ttiledb_query_status_from_str(
    constchar*str,tiledb_query_status_t*query_status);

    TILEDB_EXPORTint32_t
    tiledb_walk_order_to_str(tiledb_walk_order_twalk_order,constchar**str);

    TILEDB_EXPORTint32_t
    tiledb_walk_order_from_str(constchar*str,tiledb_walk_order_t*walk_order);

    TILEDB_EXPORTint32_t
    tiledb_vfs_mode_to_str(tiledb_vfs_mode_tvfs_mode,constchar**str);

    TILEDB_EXPORTint32_t
    tiledb_vfs_mode_from_str(constchar*str,tiledb_vfs_mode_t*vfs_mode);

    /********************************/
    /*CONSTANTS*/
    /********************************/

    #defineTILEDB_OK0
    #defineTILEDB_ERR(-1)
    #defineTILEDB_OOM(-2)
    TILEDB_DEPRECATED_EXPORTconstchar*tiledb_coords(void);

    TILEDB_EXPORTuint32_ttiledb_var_num(void);

    TILEDB_EXPORTuint32_ttiledb_max_path(void);

    TILEDB_EXPORTuint64_ttiledb_datatype_size(tiledb_datatype_ttype);

    TILEDB_EXPORTuint64_ttiledb_offset_size(void);

    TILEDB_EXPORTuint64_ttiledb_timestamp_now_ms(void);

    #defineTILEDB_COORDStiledb_coords()
    #defineTILEDB_VAR_NUMtiledb_var_num()
    #defineTILEDB_MAX_PATHtiledb_max_path()
    #defineTILEDB_OFFSET_SIZEtiledb_offset_size()
    #defineTILEDB_TIMESTAMP_NOW_MStiledb_timestamp_now_ms()
    /********************************/
    /*VERSION*/
    /********************************/

    TILEDB_EXPORTvoidtiledb_version(int32_t*major,int32_t*minor,int32_t*rev);

    /***********************************/
    /*TILEDBTYPES*/
    /***********************************/

    typedefstructtiledb_array_ttiledb_array_t;

    typedefstructtiledb_buffer_ttiledb_buffer_t;

    typedefstructtiledb_buffer_list_ttiledb_buffer_list_t;

    typedefstructtiledb_config_ttiledb_config_t;

    typedefstructtiledb_config_iter_ttiledb_config_iter_t;

    typedefstructtiledb_ctx_ttiledb_ctx_t;

    typedefstructtiledb_error_ttiledb_error_t;

    typedefstructtiledb_attribute_ttiledb_attribute_t;

    typedefstructtiledb_array_schema_ttiledb_array_schema_t;

    typedefstructtiledb_dimension_ttiledb_dimension_t;

    typedefstructtiledb_domain_ttiledb_domain_t;

    typedefstructtiledb_filter_ttiledb_filter_t;

    typedefstructtiledb_filter_list_ttiledb_filter_list_t;

    typedefstructtiledb_query_ttiledb_query_t;

    typedefstructtiledb_query_condition_ttiledb_query_condition_t;

    typedefstructtiledb_vfs_ttiledb_vfs_t;

    typedefstructtiledb_vfs_fh_ttiledb_vfs_fh_t;

    typedefstructtiledb_fragment_info_ttiledb_fragment_info_t;

    /***********************************/
    /*ERROR*/
    /***********************************/

    TILEDB_EXPORTint32_t
    tiledb_error_message(tiledb_error_t*err,constchar**errmsg);

    TILEDB_EXPORTvoidtiledb_error_free(tiledb_error_t**err);

    /***********************************/
    /*BUFFER*/
    /***********************************/

    TILEDB_EXPORTint32_t
    tiledb_buffer_alloc(tiledb_ctx_t*ctx,tiledb_buffer_t**buffer);

    TILEDB_EXPORTvoidtiledb_buffer_free(tiledb_buffer_t**buffer);

    TILEDB_EXPORTint32_ttiledb_buffer_set_type(
    tiledb_ctx_t*ctx,tiledb_buffer_t*buffer,tiledb_datatype_tdatatype);

    TILEDB_EXPORTint32_ttiledb_buffer_get_type(
    tiledb_ctx_t*ctx,
    consttiledb_buffer_t*buffer,
    tiledb_datatype_t*datatype);

    TILEDB_EXPORTint32_ttiledb_buffer_get_data(
    tiledb_ctx_t*ctx,
    consttiledb_buffer_t*buffer,
    void**data,
    uint64_t*num_bytes);

    TILEDB_EXPORTint32_ttiledb_buffer_set_data(
    tiledb_ctx_t*ctx,tiledb_buffer_t*buffer,void*data,uint64_tsize);

    /***********************************/
    /*BUFFERLIST*/
    /***********************************/

    TILEDB_EXPORTint32_t
    tiledb_buffer_list_alloc(tiledb_ctx_t*ctx,tiledb_buffer_list_t**buffer_list);

    TILEDB_EXPORTvoidtiledb_buffer_list_free(tiledb_buffer_list_t**buffer_list);

    TILEDB_EXPORTint32_ttiledb_buffer_list_get_num_buffers(
    tiledb_ctx_t*ctx,
    consttiledb_buffer_list_t*buffer_list,
    uint64_t*num_buffers);

    TILEDB_EXPORTint32_ttiledb_buffer_list_get_buffer(
    tiledb_ctx_t*ctx,
    consttiledb_buffer_list_t*buffer_list,
    uint64_tbuffer_idx,
    tiledb_buffer_t**buffer);

    TILEDB_EXPORTint32_ttiledb_buffer_list_get_total_size(
    tiledb_ctx_t*ctx,
    consttiledb_buffer_list_t*buffer_list,
    uint64_t*total_size);

    TILEDB_EXPORTint32_ttiledb_buffer_list_flatten(
    tiledb_ctx_t*ctx,
    consttiledb_buffer_list_t*buffer_list,
    tiledb_buffer_t**buffer);

    /***********************************/
    /*CONFIG*/
    /***********************************/

    TILEDB_EXPORTint32_t
    tiledb_config_alloc(tiledb_config_t**config,tiledb_error_t**error);

    TILEDB_EXPORTvoidtiledb_config_free(tiledb_config_t**config);

    TILEDB_EXPORTint32_ttiledb_config_set(
    tiledb_config_t*config,
    constchar*param,
    constchar*value,
    tiledb_error_t**error);

    TILEDB_EXPORTint32_ttiledb_config_get(
    tiledb_config_t*config,
    constchar*param,
    constchar**value,
    tiledb_error_t**error);

    TILEDB_EXPORTint32_ttiledb_config_load_from_file(
    tiledb_config_t*config,constchar*filename,tiledb_error_t**error);

    TILEDB_EXPORTint32_ttiledb_config_unset(
    tiledb_config_t*config,constchar*param,tiledb_error_t**error);

    TILEDB_EXPORTint32_ttiledb_config_save_to_file(
    tiledb_config_t*config,constchar*filename,tiledb_error_t**error);

    TILEDB_EXPORTint32_ttiledb_config_compare(
    tiledb_config_t*lhs,tiledb_config_t*rhs,uint8_t*equal);

    /********************************/
    /*CONFIGITER*/
    /********************************/

    TILEDB_EXPORTint32_ttiledb_config_iter_alloc(
    tiledb_config_t*config,
    constchar*prefix,
    tiledb_config_iter_t**config_iter,
    tiledb_error_t**error);

    TILEDB_EXPORTint32_ttiledb_config_iter_reset(
    tiledb_config_t*config,
    tiledb_config_iter_t*config_iter,
    constchar*prefix,
    tiledb_error_t**error);

    TILEDB_EXPORTvoidtiledb_config_iter_free(tiledb_config_iter_t**config_iter);

    TILEDB_EXPORTint32_ttiledb_config_iter_here(
    tiledb_config_iter_t*config_iter,
    constchar**param,
    constchar**value,
    tiledb_error_t**error);

    TILEDB_EXPORTint32_ttiledb_config_iter_next(
    tiledb_config_iter_t*config_iter,tiledb_error_t**error);

    TILEDB_EXPORTint32_ttiledb_config_iter_done(
    tiledb_config_iter_t*config_iter,int32_t*done,tiledb_error_t**error);

    /***********************************/
    /*CONTEXT*/
    /***********************************/

    TILEDB_EXPORTint32_t
    tiledb_ctx_alloc(tiledb_config_t*config,tiledb_ctx_t**ctx);

    TILEDB_EXPORTvoidtiledb_ctx_free(tiledb_ctx_t**ctx);

    TILEDB_EXPORTint32_t
    tiledb_ctx_get_stats(tiledb_ctx_t*ctx,char**stats_json);

    TILEDB_EXPORTint32_t
    tiledb_ctx_get_config(tiledb_ctx_t*ctx,tiledb_config_t**config);

    TILEDB_EXPORTint32_t
    tiledb_ctx_get_last_error(tiledb_ctx_t*ctx,tiledb_error_t**err);

    TILEDB_EXPORTint32_ttiledb_ctx_is_supported_fs(
    tiledb_ctx_t*ctx,tiledb_filesystem_tfs,int32_t*is_supported);

    TILEDB_EXPORTint32_ttiledb_ctx_cancel_tasks(tiledb_ctx_t*ctx);

    TILEDB_EXPORTint32_t
    tiledb_ctx_set_tag(tiledb_ctx_t*ctx,constchar*key,constchar*value);

    /***********************************/
    /*GROUP*/
    /***********************************/

    TILEDB_EXPORTint32_t
    tiledb_group_create(tiledb_ctx_t*ctx,constchar*group_uri);

    /***********************************/
    /*FILTER*/
    /***********************************/

    TILEDB_EXPORTint32_ttiledb_filter_alloc(
    tiledb_ctx_t*ctx,tiledb_filter_type_ttype,tiledb_filter_t**filter);

    TILEDB_EXPORTvoidtiledb_filter_free(tiledb_filter_t**filter);

    TILEDB_EXPORTint32_ttiledb_filter_get_type(
    tiledb_ctx_t*ctx,tiledb_filter_t*filter,tiledb_filter_type_t*type);

    TILEDB_EXPORTint32_ttiledb_filter_set_option(
    tiledb_ctx_t*ctx,
    tiledb_filter_t*filter,
    tiledb_filter_option_toption,
    constvoid*value);

    TILEDB_EXPORTint32_ttiledb_filter_get_option(
    tiledb_ctx_t*ctx,
    tiledb_filter_t*filter,
    tiledb_filter_option_toption,
    void*value);

    /***********************************/
    /*FILTERLIST*/
    /***********************************/

    TILEDB_EXPORTint32_t
    tiledb_filter_list_alloc(tiledb_ctx_t*ctx,tiledb_filter_list_t**filter_list);

    TILEDB_EXPORTvoidtiledb_filter_list_free(tiledb_filter_list_t**filter_list);

    TILEDB_EXPORTint32_ttiledb_filter_list_add_filter(
    tiledb_ctx_t*ctx,
    tiledb_filter_list_t*filter_list,
    tiledb_filter_t*filter);

    TILEDB_EXPORTint32_ttiledb_filter_list_set_max_chunk_size(
    tiledb_ctx_t*ctx,
    consttiledb_filter_list_t*filter_list,
    uint32_tmax_chunk_size);

    TILEDB_EXPORTint32_ttiledb_filter_list_get_nfilters(
    tiledb_ctx_t*ctx,
    consttiledb_filter_list_t*filter_list,
    uint32_t*nfilters);

    TILEDB_EXPORTint32_ttiledb_filter_list_get_filter_from_index(
    tiledb_ctx_t*ctx,
    consttiledb_filter_list_t*filter_list,
    uint32_tindex,
    tiledb_filter_t**filter);

    TILEDB_EXPORTint32_ttiledb_filter_list_get_max_chunk_size(
    tiledb_ctx_t*ctx,
    consttiledb_filter_list_t*filter_list,
    uint32_t*max_chunk_size);

    /***********************************/
    /*ATTRIBUTE*/
    /***********************************/

    TILEDB_EXPORTint32_ttiledb_attribute_alloc(
    tiledb_ctx_t*ctx,
    constchar*name,
    tiledb_datatype_ttype,
    tiledb_attribute_t**attr);

    TILEDB_EXPORTvoidtiledb_attribute_free(tiledb_attribute_t**attr);

    TILEDB_EXPORTint32_ttiledb_attribute_set_nullable(
    tiledb_ctx_t*ctx,tiledb_attribute_t*attr,uint8_tnullable);

    TILEDB_EXPORTint32_ttiledb_attribute_set_filter_list(
    tiledb_ctx_t*ctx,
    tiledb_attribute_t*attr,
    tiledb_filter_list_t*filter_list);

    TILEDB_EXPORTint32_ttiledb_attribute_set_cell_val_num(
    tiledb_ctx_t*ctx,tiledb_attribute_t*attr,uint32_tcell_val_num);

    TILEDB_EXPORTint32_ttiledb_attribute_get_name(
    tiledb_ctx_t*ctx,consttiledb_attribute_t*attr,constchar**name);

    TILEDB_EXPORTint32_ttiledb_attribute_get_type(
    tiledb_ctx_t*ctx,consttiledb_attribute_t*attr,tiledb_datatype_t*type);

    TILEDB_EXPORTint32_ttiledb_attribute_get_nullable(
    tiledb_ctx_t*ctx,tiledb_attribute_t*attr,uint8_t*nullable);

    TILEDB_EXPORTint32_ttiledb_attribute_get_filter_list(
    tiledb_ctx_t*ctx,
    tiledb_attribute_t*attr,
    tiledb_filter_list_t**filter_list);

    TILEDB_EXPORTint32_ttiledb_attribute_get_cell_val_num(
    tiledb_ctx_t*ctx,consttiledb_attribute_t*attr,uint32_t*cell_val_num);

    TILEDB_EXPORTint32_ttiledb_attribute_get_cell_size(
    tiledb_ctx_t*ctx,consttiledb_attribute_t*attr,uint64_t*cell_size);

    TILEDB_EXPORTint32_ttiledb_attribute_dump(
    tiledb_ctx_t*ctx,consttiledb_attribute_t*attr,FILE*out);

    TILEDB_EXPORTint32_ttiledb_attribute_set_fill_value(
    tiledb_ctx_t*ctx,
    tiledb_attribute_t*attr,
    constvoid*value,
    uint64_tsize);

    TILEDB_EXPORTint32_ttiledb_attribute_get_fill_value(
    tiledb_ctx_t*ctx,
    tiledb_attribute_t*attr,
    constvoid**value,
    uint64_t*size);

    TILEDB_EXPORTint32_ttiledb_attribute_set_fill_value_nullable(
    tiledb_ctx_t*ctx,
    tiledb_attribute_t*attr,
    constvoid*value,
    uint64_tsize,
    uint8_tvalidity);

    TILEDB_EXPORTint32_ttiledb_attribute_get_fill_value_nullable(
    tiledb_ctx_t*ctx,
    tiledb_attribute_t*attr,
    constvoid**value,
    uint64_t*size,
    uint8_t*valid);

    /***********************************/
    /*DOMAIN*/
    /***********************************/

    TILEDB_EXPORTint32_t
    tiledb_domain_alloc(tiledb_ctx_t*ctx,tiledb_domain_t**domain);

    TILEDB_EXPORTvoidtiledb_domain_free(tiledb_domain_t**domain);

    TILEDB_EXPORTint32_ttiledb_domain_get_type(
    tiledb_ctx_t*ctx,consttiledb_domain_t*domain,tiledb_datatype_t*type);

    TILEDB_EXPORTint32_ttiledb_domain_get_ndim(
    tiledb_ctx_t*ctx,consttiledb_domain_t*domain,uint32_t*ndim);

    TILEDB_EXPORTint32_ttiledb_domain_add_dimension(
    tiledb_ctx_t*ctx,tiledb_domain_t*domain,tiledb_dimension_t*dim);

    TILEDB_EXPORTint32_ttiledb_domain_get_dimension_from_index(
    tiledb_ctx_t*ctx,
    consttiledb_domain_t*domain,
    uint32_tindex,
    tiledb_dimension_t**dim);

    TILEDB_EXPORTint32_ttiledb_domain_get_dimension_from_name(
    tiledb_ctx_t*ctx,
    consttiledb_domain_t*domain,
    constchar*name,
    tiledb_dimension_t**dim);

    TILEDB_EXPORTint32_ttiledb_domain_has_dimension(
    tiledb_ctx_t*ctx,
    consttiledb_domain_t*domain,
    constchar*name,
    int32_t*has_dim);

    TILEDB_EXPORTint32_t
    tiledb_domain_dump(tiledb_ctx_t*ctx,consttiledb_domain_t*domain,FILE*out);

    /***********************************/
    /*DIMENSION*/
    /***********************************/

    TILEDB_EXPORTint32_ttiledb_dimension_alloc(
    tiledb_ctx_t*ctx,
    constchar*name,
    tiledb_datatype_ttype,
    constvoid*dim_domain,
    constvoid*tile_extent,
    tiledb_dimension_t**dim);

    TILEDB_EXPORTvoidtiledb_dimension_free(tiledb_dimension_t**dim);

    TILEDB_EXPORTint32_ttiledb_dimension_set_filter_list(
    tiledb_ctx_t*ctx,
    tiledb_dimension_t*dim,
    tiledb_filter_list_t*filter_list);

    TILEDB_EXPORTint32_ttiledb_dimension_set_cell_val_num(
    tiledb_ctx_t*ctx,tiledb_dimension_t*dim,uint32_tcell_val_num);

    TILEDB_EXPORTint32_ttiledb_dimension_get_filter_list(
    tiledb_ctx_t*ctx,
    tiledb_dimension_t*dim,
    tiledb_filter_list_t**filter_list);

    TILEDB_EXPORTint32_ttiledb_dimension_get_cell_val_num(
    tiledb_ctx_t*ctx,consttiledb_dimension_t*dim,uint32_t*cell_val_num);

    TILEDB_EXPORTint32_ttiledb_dimension_get_name(
    tiledb_ctx_t*ctx,consttiledb_dimension_t*dim,constchar**name);

    TILEDB_EXPORTint32_ttiledb_dimension_get_type(
    tiledb_ctx_t*ctx,consttiledb_dimension_t*dim,tiledb_datatype_t*type);

    TILEDB_EXPORTint32_ttiledb_dimension_get_domain(
    tiledb_ctx_t*ctx,consttiledb_dimension_t*dim,constvoid**domain);

    TILEDB_EXPORTint32_ttiledb_dimension_get_tile_extent(
    tiledb_ctx_t*ctx,consttiledb_dimension_t*dim,constvoid**tile_extent);

    TILEDB_EXPORTint32_ttiledb_dimension_dump(
    tiledb_ctx_t*ctx,consttiledb_dimension_t*dim,FILE*out);

    /***********************************/
    /*ARRAYSCHEMA*/
    /***********************************/

    TILEDB_EXPORTint32_ttiledb_array_schema_alloc(
    tiledb_ctx_t*ctx,
    tiledb_array_type_tarray_type,
    tiledb_array_schema_t**array_schema);

    TILEDB_EXPORTvoidtiledb_array_schema_free(
    tiledb_array_schema_t**array_schema);

    TILEDB_EXPORTint32_ttiledb_array_schema_add_attribute(
    tiledb_ctx_t*ctx,
    tiledb_array_schema_t*array_schema,
    tiledb_attribute_t*attr);

    TILEDB_EXPORTint32_ttiledb_array_schema_set_allows_dups(
    tiledb_ctx_t*ctx,tiledb_array_schema_t*array_schema,intallows_dups);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_allows_dups(
    tiledb_ctx_t*ctx,tiledb_array_schema_t*array_schema,int*allows_dups);

    TILEDB_EXPORTint32_ttiledb_array_schema_set_domain(
    tiledb_ctx_t*ctx,
    tiledb_array_schema_t*array_schema,
    tiledb_domain_t*domain);

    TILEDB_EXPORTint32_ttiledb_array_schema_set_capacity(
    tiledb_ctx_t*ctx,tiledb_array_schema_t*array_schema,uint64_tcapacity);

    TILEDB_EXPORTint32_ttiledb_array_schema_set_cell_order(
    tiledb_ctx_t*ctx,
    tiledb_array_schema_t*array_schema,
    tiledb_layout_tcell_order);

    TILEDB_EXPORTint32_ttiledb_array_schema_set_tile_order(
    tiledb_ctx_t*ctx,
    tiledb_array_schema_t*array_schema,
    tiledb_layout_ttile_order);

    TILEDB_EXPORTint32_ttiledb_array_schema_set_coords_filter_list(
    tiledb_ctx_t*ctx,
    tiledb_array_schema_t*array_schema,
    tiledb_filter_list_t*filter_list);

    TILEDB_EXPORTint32_ttiledb_array_schema_set_offsets_filter_list(
    tiledb_ctx_t*ctx,
    tiledb_array_schema_t*array_schema,
    tiledb_filter_list_t*filter_list);

    TILEDB_EXPORTint32_ttiledb_array_schema_set_validity_filter_list(
    tiledb_ctx_t*ctx,
    tiledb_array_schema_t*array_schema,
    tiledb_filter_list_t*filter_list);

    TILEDB_EXPORTint32_ttiledb_array_schema_check(
    tiledb_ctx_t*ctx,tiledb_array_schema_t*array_schema);

    TILEDB_EXPORTint32_ttiledb_array_schema_load(
    tiledb_ctx_t*ctx,
    constchar*array_uri,
    tiledb_array_schema_t**array_schema);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_array_schema_load_with_key(
    tiledb_ctx_t*ctx,
    constchar*array_uri,
    tiledb_encryption_type_tencryption_type,
    constvoid*encryption_key,
    uint32_tkey_length,
    tiledb_array_schema_t**array_schema);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_array_type(
    tiledb_ctx_t*ctx,
    consttiledb_array_schema_t*array_schema,
    tiledb_array_type_t*array_type);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_capacity(
    tiledb_ctx_t*ctx,
    consttiledb_array_schema_t*array_schema,
    uint64_t*capacity);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_cell_order(
    tiledb_ctx_t*ctx,
    consttiledb_array_schema_t*array_schema,
    tiledb_layout_t*cell_order);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_coords_filter_list(
    tiledb_ctx_t*ctx,
    tiledb_array_schema_t*array_schema,
    tiledb_filter_list_t**filter_list);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_offsets_filter_list(
    tiledb_ctx_t*ctx,
    tiledb_array_schema_t*array_schema,
    tiledb_filter_list_t**filter_list);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_validity_filter_list(
    tiledb_ctx_t*ctx,
    tiledb_array_schema_t*array_schema,
    tiledb_filter_list_t**filter_list);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_domain(
    tiledb_ctx_t*ctx,
    consttiledb_array_schema_t*array_schema,
    tiledb_domain_t**domain);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_tile_order(
    tiledb_ctx_t*ctx,
    consttiledb_array_schema_t*array_schema,
    tiledb_layout_t*tile_order);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_attribute_num(
    tiledb_ctx_t*ctx,
    consttiledb_array_schema_t*array_schema,
    uint32_t*attribute_num);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_attribute_from_index(
    tiledb_ctx_t*ctx,
    consttiledb_array_schema_t*array_schema,
    uint32_tindex,
    tiledb_attribute_t**attr);

    TILEDB_EXPORTint32_ttiledb_array_schema_get_attribute_from_name(
    tiledb_ctx_t*ctx,
    consttiledb_array_schema_t*array_schema,
    constchar*name,
    tiledb_attribute_t**attr);

    TILEDB_EXPORTint32_ttiledb_array_schema_has_attribute(
    tiledb_ctx_t*ctx,
    consttiledb_array_schema_t*array_schema,
    constchar*name,
    int32_t*has_attr);

    TILEDB_EXPORTint32_ttiledb_array_schema_dump(
    tiledb_ctx_t*ctx,consttiledb_array_schema_t*array_schema,FILE*out);

    /***********************************/
    /*QUERY*/
    /***********************************/

    TILEDB_EXPORTint32_ttiledb_query_alloc(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    tiledb_query_type_tquery_type,
    tiledb_query_t**query);

    TILEDB_EXPORTint32_ttiledb_query_get_stats(
    tiledb_ctx_t*ctx,tiledb_query_t*query,char**stats_json);

    TILEDB_EXPORTint32_ttiledb_query_set_config(
    tiledb_ctx_t*ctx,tiledb_query_t*query,tiledb_config_t*config);

    TILEDB_EXPORTint32_ttiledb_query_get_config(
    tiledb_ctx_t*ctx,tiledb_query_t*query,tiledb_config_t**config);
    TILEDB_EXPORTint32_ttiledb_query_set_subarray(
    tiledb_ctx_t*ctx,tiledb_query_t*query,constvoid*subarray);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_query_set_buffer(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    void*buffer,
    uint64_t*buffer_size);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_query_set_buffer_var(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    uint64_t*buffer_off,
    uint64_t*buffer_off_size,
    void*buffer_val,
    uint64_t*buffer_val_size);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_query_set_buffer_nullable(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    void*buffer,
    uint64_t*buffer_size,
    uint8_t*buffer_validity_bytemap,
    uint64_t*buffer_validity_bytemap_size);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_query_set_buffer_var_nullable(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    uint64_t*buffer_off,
    uint64_t*buffer_off_size,
    void*buffer_val,
    uint64_t*buffer_val_size,
    uint8_t*buffer_validity_bytemap,
    uint64_t*buffer_validity_bytemap_size);

    TILEDB_EXPORTint32_ttiledb_query_set_data_buffer(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    void*buffer,
    uint64_t*buffer_size);

    TILEDB_EXPORTint32_ttiledb_query_set_offsets_buffer(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    uint64_t*buffer,
    uint64_t*buffer_size);

    TILEDB_EXPORTint32_ttiledb_query_set_validity_buffer(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    uint8_t*buffer,
    uint64_t*buffer_size);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_query_get_buffer(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    void**buffer,
    uint64_t**buffer_size);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_query_get_buffer_var(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    uint64_t**buffer_off,
    uint64_t**buffer_off_size,
    void**buffer_val,
    uint64_t**buffer_val_size);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_query_get_buffer_nullable(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    void**buffer,
    uint64_t**buffer_size,
    uint8_t**buffer_validity_bytemap,
    uint64_t**buffer_validity_bytemap_size);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_query_get_buffer_var_nullable(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    uint64_t**buffer_off,
    uint64_t**buffer_off_size,
    void**buffer_val,
    uint64_t**buffer_val_size,
    uint8_t**buffer_validity_bytemap,
    uint64_t**buffer_validity_bytemap_size);

    TILEDB_EXPORTint32_ttiledb_query_get_data_buffer(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    void**buffer,
    uint64_t**buffer_size);

    TILEDB_EXPORTint32_ttiledb_query_get_offsets_buffer(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    uint64_t**buffer,
    uint64_t**buffer_size);

    TILEDB_EXPORTint32_ttiledb_query_get_validity_buffer(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*name,
    uint8_t**buffer,
    uint64_t**buffer_size);

    TILEDB_EXPORTint32_ttiledb_query_set_layout(
    tiledb_ctx_t*ctx,tiledb_query_t*query,tiledb_layout_tlayout);

    TILEDB_EXPORTint32_ttiledb_query_set_condition(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    consttiledb_query_condition_t*cond);

    TILEDB_EXPORTint32_t
    tiledb_query_finalize(tiledb_ctx_t*ctx,tiledb_query_t*query);

    TILEDB_EXPORTvoidtiledb_query_free(tiledb_query_t**query);

    TILEDB_EXPORTint32_t
    tiledb_query_submit(tiledb_ctx_t*ctx,tiledb_query_t*query);

    TILEDB_EXPORTint32_ttiledb_query_submit_async(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    void(*callback)(void*),
    void*callback_data);

    TILEDB_EXPORTint32_ttiledb_query_has_results(
    tiledb_ctx_t*ctx,tiledb_query_t*query,int32_t*has_results);

    TILEDB_EXPORTint32_ttiledb_query_get_status(
    tiledb_ctx_t*ctx,tiledb_query_t*query,tiledb_query_status_t*status);

    TILEDB_EXPORTint32_ttiledb_query_get_type(
    tiledb_ctx_t*ctx,tiledb_query_t*query,tiledb_query_type_t*query_type);

    TILEDB_EXPORTint32_ttiledb_query_get_layout(
    tiledb_ctx_t*ctx,tiledb_query_t*query,tiledb_layout_t*query_layout);

    TILEDB_EXPORTint32_ttiledb_query_get_array(
    tiledb_ctx_t*ctx,tiledb_query_t*query,tiledb_array_t**array);
    TILEDB_EXPORTint32_ttiledb_query_add_range(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    uint32_tdim_idx,
    constvoid*start,
    constvoid*end,
    constvoid*stride);

    TILEDB_EXPORTint32_ttiledb_query_add_range_by_name(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*dim_name,
    constvoid*start,
    constvoid*end,
    constvoid*stride);

    TILEDB_EXPORTint32_ttiledb_query_add_range_var(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    uint32_tdim_idx,
    constvoid*start,
    uint64_tstart_size,
    constvoid*end,
    uint64_tend_size);

    TILEDB_EXPORTint32_ttiledb_query_add_range_var_by_name(
    tiledb_ctx_t*ctx,
    tiledb_query_t*query,
    constchar*dim_name,
    constvoid*start,
    uint64_tstart_size,
    constvoid*end,
    uint64_tend_size);

    TILEDB_EXPORTint32_ttiledb_query_get_range_num(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    uint32_tdim_idx,
    uint64_t*range_num);

    TILEDB_EXPORTint32_ttiledb_query_get_range_num_from_name(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    constchar*dim_name,
    uint64_t*range_num);

    TILEDB_EXPORTint32_ttiledb_query_get_range(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    uint32_tdim_idx,
    uint64_trange_idx,
    constvoid**start,
    constvoid**end,
    constvoid**stride);

    TILEDB_EXPORTint32_ttiledb_query_get_range_from_name(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    constchar*dim_name,
    uint64_trange_idx,
    constvoid**start,
    constvoid**end,
    constvoid**stride);

    TILEDB_EXPORTint32_ttiledb_query_get_range_var_size(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    uint32_tdim_idx,
    uint64_trange_idx,
    uint64_t*start_size,
    uint64_t*end_size);

    TILEDB_EXPORTint32_ttiledb_query_get_range_var_size_from_name(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    constchar*dim_name,
    uint64_trange_idx,
    uint64_t*start_size,
    uint64_t*end_size);

    TILEDB_EXPORTint32_ttiledb_query_get_range_var(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    uint32_tdim_idx,
    uint64_trange_idx,
    void*start,
    void*end);

    TILEDB_EXPORTint32_ttiledb_query_get_range_var_from_name(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    constchar*dim_name,
    uint64_trange_idx,
    void*start,
    void*end);

    TILEDB_EXPORTint32_ttiledb_query_get_est_result_size(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    constchar*name,
    uint64_t*size);

    TILEDB_EXPORTint32_ttiledb_query_get_est_result_size_var(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    constchar*name,
    uint64_t*size_off,
    uint64_t*size_val);

    TILEDB_EXPORTint32_ttiledb_query_get_est_result_size_nullable(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    constchar*name,
    uint64_t*size_val,
    uint64_t*size_validity);

    TILEDB_EXPORTint32_ttiledb_query_get_est_result_size_var_nullable(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    constchar*name,
    uint64_t*size_off,
    uint64_t*size_val,
    uint64_t*size_validity);

    TILEDB_EXPORTint32_ttiledb_query_get_fragment_num(
    tiledb_ctx_t*ctx,consttiledb_query_t*query,uint32_t*num);

    TILEDB_EXPORTint32_ttiledb_query_get_fragment_uri(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    uint64_tidx,
    constchar**uri);

    TILEDB_EXPORTint32_ttiledb_query_get_fragment_timestamp_range(
    tiledb_ctx_t*ctx,
    consttiledb_query_t*query,
    uint64_tidx,
    uint64_t*t1,
    uint64_t*t2);

    /********************************/
    /*QUERYCONDITION*/
    /********************************/

    TILEDB_EXPORTint32_ttiledb_query_condition_alloc(
    tiledb_ctx_t*ctx,tiledb_query_condition_t**cond);

    TILEDB_EXPORTvoidtiledb_query_condition_free(tiledb_query_condition_t**cond);

    TILEDB_EXPORTint32_ttiledb_query_condition_init(
    tiledb_ctx_t*ctx,
    tiledb_query_condition_t*cond,
    constchar*attribute_name,
    constvoid*condition_value,
    uint64_tcondition_value_size,
    tiledb_query_condition_op_top);

    TILEDB_EXPORTint32_ttiledb_query_condition_combine(
    tiledb_ctx_t*ctx,
    consttiledb_query_condition_t*left_cond,
    consttiledb_query_condition_t*right_cond,
    tiledb_query_condition_combination_op_tcombination_op,
    tiledb_query_condition_t**combined_cond);

    /***********************************/
    /*ARRAY*/
    /***********************************/

    TILEDB_EXPORTint32_ttiledb_array_alloc(
    tiledb_ctx_t*ctx,constchar*array_uri,tiledb_array_t**array);

    TILEDB_EXPORTint32_ttiledb_array_set_open_timestamp_start(
    tiledb_ctx_t*ctx,tiledb_array_t*array,uint64_ttimestamp_start);

    TILEDB_EXPORTint32_ttiledb_array_set_open_timestamp_end(
    tiledb_ctx_t*ctx,tiledb_array_t*array,uint64_ttimestamp_end);

    TILEDB_EXPORTint32_ttiledb_array_get_open_timestamp_start(
    tiledb_ctx_t*ctx,tiledb_array_t*array,uint64_t*timestamp_start);

    TILEDB_EXPORTint32_ttiledb_array_get_open_timestamp_end(
    tiledb_ctx_t*ctx,tiledb_array_t*array,uint64_t*timestamp_end);

    TILEDB_EXPORTint32_ttiledb_array_open(
    tiledb_ctx_t*ctx,tiledb_array_t*array,tiledb_query_type_tquery_type);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_array_open_at(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    tiledb_query_type_tquery_type,
    uint64_ttimestamp);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_array_open_with_key(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    tiledb_query_type_tquery_type,
    tiledb_encryption_type_tencryption_type,
    constvoid*encryption_key,
    uint32_tkey_length);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_array_open_at_with_key(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    tiledb_query_type_tquery_type,
    tiledb_encryption_type_tencryption_type,
    constvoid*encryption_key,
    uint32_tkey_length,
    uint64_ttimestamp);

    TILEDB_EXPORTint32_ttiledb_array_is_open(
    tiledb_ctx_t*ctx,tiledb_array_t*array,int32_t*is_open);

    TILEDB_EXPORTint32_t
    tiledb_array_reopen(tiledb_ctx_t*ctx,tiledb_array_t*array);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_array_reopen_at(
    tiledb_ctx_t*ctx,tiledb_array_t*array,uint64_ttimestamp);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_array_get_timestamp(
    tiledb_ctx_t*ctx,tiledb_array_t*array,uint64_t*timestamp);

    TILEDB_EXPORTint32_ttiledb_array_set_config(
    tiledb_ctx_t*ctx,tiledb_array_t*array,tiledb_config_t*config);

    TILEDB_EXPORTint32_ttiledb_array_get_config(
    tiledb_ctx_t*ctx,tiledb_array_t*array,tiledb_config_t**config);

    TILEDB_EXPORTint32_t
    tiledb_array_close(tiledb_ctx_t*ctx,tiledb_array_t*array);

    TILEDB_EXPORTvoidtiledb_array_free(tiledb_array_t**array);

    TILEDB_EXPORTint32_ttiledb_array_get_schema(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    tiledb_array_schema_t**array_schema);

    TILEDB_EXPORTint32_ttiledb_array_get_query_type(
    tiledb_ctx_t*ctx,tiledb_array_t*array,tiledb_query_type_t*query_type);

    TILEDB_EXPORTint32_ttiledb_array_create(
    tiledb_ctx_t*ctx,
    constchar*array_uri,
    consttiledb_array_schema_t*array_schema);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_array_create_with_key(
    tiledb_ctx_t*ctx,
    constchar*array_uri,
    consttiledb_array_schema_t*array_schema,
    tiledb_encryption_type_tencryption_type,
    constvoid*encryption_key,
    uint32_tkey_length);

    TILEDB_EXPORTint32_ttiledb_array_consolidate(
    tiledb_ctx_t*ctx,constchar*array_uri,tiledb_config_t*config);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_array_consolidate_with_key(
    tiledb_ctx_t*ctx,
    constchar*array_uri,
    tiledb_encryption_type_tencryption_type,
    constvoid*encryption_key,
    uint32_tkey_length,
    tiledb_config_t*config);

    TILEDB_EXPORTint32_ttiledb_array_vacuum(
    tiledb_ctx_t*ctx,constchar*array_uri,tiledb_config_t*config);

    TILEDB_EXPORTint32_ttiledb_array_get_non_empty_domain(
    tiledb_ctx_t*ctx,tiledb_array_t*array,void*domain,int32_t*is_empty);

    TILEDB_EXPORTint32_ttiledb_array_get_non_empty_domain_from_index(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    uint32_tidx,
    void*domain,
    int32_t*is_empty);

    TILEDB_EXPORTint32_ttiledb_array_get_non_empty_domain_from_name(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    constchar*name,
    void*domain,
    int32_t*is_empty);

    TILEDB_EXPORTint32_ttiledb_array_get_non_empty_domain_var_size_from_index(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    uint32_tidx,
    uint64_t*start_size,
    uint64_t*end_size,
    int32_t*is_empty);

    TILEDB_EXPORTint32_ttiledb_array_get_non_empty_domain_var_size_from_name(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    constchar*name,
    uint64_t*start_size,
    uint64_t*end_size,
    int32_t*is_empty);

    TILEDB_EXPORTint32_ttiledb_array_get_non_empty_domain_var_from_index(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    uint32_tidx,
    void*start,
    void*end,
    int32_t*is_empty);

    TILEDB_EXPORTint32_ttiledb_array_get_non_empty_domain_var_from_name(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    constchar*name,
    void*start,
    void*end,
    int32_t*is_empty);

    TILEDB_EXPORTint32_ttiledb_array_get_uri(
    tiledb_ctx_t*ctx,tiledb_array_t*array,constchar**array_uri);

    TILEDB_EXPORTint32_ttiledb_array_encryption_type(
    tiledb_ctx_t*ctx,
    constchar*array_uri,
    tiledb_encryption_type_t*encryption_type);

    TILEDB_EXPORTint32_ttiledb_array_put_metadata(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    constchar*key,
    tiledb_datatype_tvalue_type,
    uint32_tvalue_num,
    constvoid*value);

    TILEDB_EXPORTint32_ttiledb_array_delete_metadata(
    tiledb_ctx_t*ctx,tiledb_array_t*array,constchar*key);

    TILEDB_EXPORTint32_ttiledb_array_get_metadata(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    constchar*key,
    tiledb_datatype_t*value_type,
    uint32_t*value_num,
    constvoid**value);

    TILEDB_EXPORTint32_ttiledb_array_get_metadata_num(
    tiledb_ctx_t*ctx,tiledb_array_t*array,uint64_t*num);

    TILEDB_EXPORTint32_ttiledb_array_get_metadata_from_index(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    uint64_tindex,
    constchar**key,
    uint32_t*key_len,
    tiledb_datatype_t*value_type,
    uint32_t*value_num,
    constvoid**value);

    TILEDB_EXPORTint32_ttiledb_array_has_metadata_key(
    tiledb_ctx_t*ctx,
    tiledb_array_t*array,
    constchar*key,
    tiledb_datatype_t*value_type,
    int32_t*has_key);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_array_consolidate_metadata(
    tiledb_ctx_t*ctx,constchar*array_uri,tiledb_config_t*config);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_array_consolidate_metadata_with_key(
    tiledb_ctx_t*ctx,
    constchar*array_uri,
    tiledb_encryption_type_tencryption_type,
    constvoid*encryption_key,
    uint32_tkey_length,
    tiledb_config_t*config);

    /***********************************/
    /*OBJECTMANAGEMENT*/
    /***********************************/

    TILEDB_EXPORTint32_t
    tiledb_object_type(tiledb_ctx_t*ctx,constchar*path,tiledb_object_t*type);

    TILEDB_EXPORTint32_ttiledb_object_remove(tiledb_ctx_t*ctx,constchar*path);

    TILEDB_EXPORTint32_ttiledb_object_move(
    tiledb_ctx_t*ctx,constchar*old_path,constchar*new_path);

    TILEDB_EXPORTint32_ttiledb_object_walk(
    tiledb_ctx_t*ctx,
    constchar*path,
    tiledb_walk_order_torder,
    int32_t(*callback)(constchar*,tiledb_object_t,void*),
    void*data);

    TILEDB_EXPORTint32_ttiledb_object_ls(
    tiledb_ctx_t*ctx,
    constchar*path,
    int32_t(*callback)(constchar*,tiledb_object_t,void*),
    void*data);

    /********************************/
    /*VIRTUALFILESYSTEM*/
    /********************************/

    TILEDB_EXPORTint32_ttiledb_vfs_alloc(
    tiledb_ctx_t*ctx,tiledb_config_t*config,tiledb_vfs_t**vfs);

    TILEDB_EXPORTvoidtiledb_vfs_free(tiledb_vfs_t**vfs);

    TILEDB_EXPORTint32_ttiledb_vfs_get_config(
    tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,tiledb_config_t**config);

    TILEDB_EXPORTint32_t
    tiledb_vfs_create_bucket(tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri);

    TILEDB_EXPORTint32_t
    tiledb_vfs_remove_bucket(tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri);

    TILEDB_EXPORTint32_t
    tiledb_vfs_empty_bucket(tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri);

    TILEDB_EXPORTint32_ttiledb_vfs_is_empty_bucket(
    tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri,int32_t*is_empty);

    TILEDB_EXPORTint32_ttiledb_vfs_is_bucket(
    tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri,int32_t*is_bucket);

    TILEDB_EXPORTint32_t
    tiledb_vfs_create_dir(tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri);

    TILEDB_EXPORTint32_ttiledb_vfs_is_dir(
    tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri,int32_t*is_dir);

    TILEDB_EXPORTint32_t
    tiledb_vfs_remove_dir(tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri);

    TILEDB_EXPORTint32_ttiledb_vfs_is_file(
    tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri,int32_t*is_file);

    TILEDB_EXPORTint32_t
    tiledb_vfs_remove_file(tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri);

    TILEDB_EXPORTint32_ttiledb_vfs_dir_size(
    tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri,uint64_t*size);

    TILEDB_EXPORTint32_ttiledb_vfs_file_size(
    tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri,uint64_t*size);

    TILEDB_EXPORTint32_ttiledb_vfs_move_file(
    tiledb_ctx_t*ctx,
    tiledb_vfs_t*vfs,
    constchar*old_uri,
    constchar*new_uri);

    TILEDB_EXPORTint32_ttiledb_vfs_move_dir(
    tiledb_ctx_t*ctx,
    tiledb_vfs_t*vfs,
    constchar*old_uri,
    constchar*new_uri);

    TILEDB_EXPORTint32_ttiledb_vfs_copy_file(
    tiledb_ctx_t*ctx,
    tiledb_vfs_t*vfs,
    constchar*old_uri,
    constchar*new_uri);

    TILEDB_EXPORTint32_ttiledb_vfs_copy_dir(
    tiledb_ctx_t*ctx,
    tiledb_vfs_t*vfs,
    constchar*old_uri,
    constchar*new_uri);

    TILEDB_EXPORTint32_ttiledb_vfs_open(
    tiledb_ctx_t*ctx,
    tiledb_vfs_t*vfs,
    constchar*uri,
    tiledb_vfs_mode_tmode,
    tiledb_vfs_fh_t**fh);

    TILEDB_EXPORTint32_ttiledb_vfs_close(tiledb_ctx_t*ctx,tiledb_vfs_fh_t*fh);

    TILEDB_EXPORTint32_ttiledb_vfs_read(
    tiledb_ctx_t*ctx,
    tiledb_vfs_fh_t*fh,
    uint64_toffset,
    void*buffer,
    uint64_tnbytes);

    TILEDB_EXPORTint32_ttiledb_vfs_write(
    tiledb_ctx_t*ctx,
    tiledb_vfs_fh_t*fh,
    constvoid*buffer,
    uint64_tnbytes);

    TILEDB_EXPORTint32_ttiledb_vfs_sync(tiledb_ctx_t*ctx,tiledb_vfs_fh_t*fh);

    TILEDB_EXPORTint32_ttiledb_vfs_ls(
    tiledb_ctx_t*ctx,
    tiledb_vfs_t*vfs,
    constchar*path,
    int32_t(*callback)(constchar*,void*),
    void*data);

    TILEDB_EXPORTvoidtiledb_vfs_fh_free(tiledb_vfs_fh_t**fh);

    TILEDB_EXPORTint32_ttiledb_vfs_fh_is_closed(
    tiledb_ctx_t*ctx,tiledb_vfs_fh_t*fh,int32_t*is_closed);

    TILEDB_EXPORTint32_t
    tiledb_vfs_touch(tiledb_ctx_t*ctx,tiledb_vfs_t*vfs,constchar*uri);

    /********************************/
    /*URI*/
    /********************************/

    TILEDB_EXPORTint32_ttiledb_uri_to_path(
    tiledb_ctx_t*ctx,constchar*uri,char*path_out,uint32_t*path_length);

    /********************************/
    /*Stats*/
    /********************************/

    TILEDB_EXPORTint32_ttiledb_stats_enable(void);

    TILEDB_EXPORTint32_ttiledb_stats_disable(void);

    TILEDB_EXPORTint32_ttiledb_stats_reset(void);

    TILEDB_EXPORTint32_ttiledb_stats_dump(FILE*out);

    TILEDB_EXPORTint32_ttiledb_stats_dump_str(char**out);

    TILEDB_EXPORTint32_ttiledb_stats_raw_dump(FILE*out);

    TILEDB_EXPORTint32_ttiledb_stats_raw_dump_str(char**out);

    TILEDB_EXPORTint32_ttiledb_stats_free_str(char**out);

    /********************************/
    /*HeapProfiler*/
    /********************************/

    TILEDB_EXPORTint32_ttiledb_heap_profiler_enable(
    constchar*file_name_prefix,
    uint64_tdump_interval_ms,
    uint64_tdump_interval_bytes,
    uint64_tdump_threshold_bytes);

    /********************************/
    /*FRAGMENTINFO*/
    /********************************/

    TILEDB_EXPORTint32_ttiledb_fragment_info_alloc(
    tiledb_ctx_t*ctx,
    constchar*array_uri,
    tiledb_fragment_info_t**fragment_info);

    TILEDB_EXPORTvoidtiledb_fragment_info_free(
    tiledb_fragment_info_t**fragment_info);

    TILEDB_EXPORTint32_ttiledb_fragment_info_load(
    tiledb_ctx_t*ctx,tiledb_fragment_info_t*fragment_info);

    TILEDB_DEPRECATED_EXPORTint32_ttiledb_fragment_info_load_with_key(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    tiledb_encryption_type_tencryption_type,
    constvoid*encryption_key,
    uint32_tkey_length);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_fragment_num(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_t*fragment_num);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_fragment_uri(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    constchar**uri);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_fragment_size(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint64_t*size);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_dense(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    int32_t*dense);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_sparse(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    int32_t*sparse);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_timestamp_range(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint64_t*start,
    uint64_t*end);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_non_empty_domain_from_index(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint32_tdid,
    void*domain);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_non_empty_domain_from_name(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    constchar*dim_name,
    void*domain);

    TILEDB_EXPORTint32_t
    tiledb_fragment_info_get_non_empty_domain_var_size_from_index(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint32_tdid,
    uint64_t*start_size,
    uint64_t*end_size);

    TILEDB_EXPORTint32_t
    tiledb_fragment_info_get_non_empty_domain_var_size_from_name(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    constchar*dim_name,
    uint64_t*start_size,
    uint64_t*end_size);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_non_empty_domain_var_from_index(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint32_tdid,
    void*start,
    void*end);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_non_empty_domain_var_from_name(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    constchar*dim_name,
    void*start,
    void*end);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_mbr_num(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint64_t*mbr_num);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_mbr_from_index(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint32_tmid,
    uint32_tdid,
    void*mbr);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_mbr_from_name(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint32_tmid,
    constchar*dim_name,
    void*mbr);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_mbr_var_size_from_index(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint32_tmid,
    uint32_tdid,
    uint64_t*start_size,
    uint64_t*end_size);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_mbr_var_size_from_name(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint32_tmid,
    constchar*dim_name,
    uint64_t*start_size,
    uint64_t*end_size);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_mbr_var_from_index(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint32_tmid,
    uint32_tdid,
    void*start,
    void*end);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_mbr_var_from_name(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint32_tmid,
    constchar*dim_name,
    void*start,
    void*end);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_cell_num(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint64_t*cell_num);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_version(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    uint32_t*version);

    TILEDB_EXPORTint32_ttiledb_fragment_info_has_consolidated_metadata(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    int32_t*has);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_unconsolidated_metadata_num(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_t*unconsolidated);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_to_vacuum_num(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_t*to_vacuum_num);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_to_vacuum_uri(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    constchar**uri);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_array_schema(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    tiledb_array_schema_t**array_schema);

    TILEDB_EXPORTint32_ttiledb_fragment_info_get_array_schema_name(
    tiledb_ctx_t*ctx,
    tiledb_fragment_info_t*fragment_info,
    uint32_tfid,
    constchar**schema_name);

    TILEDB_EXPORTint32_ttiledb_fragment_info_dump(
    tiledb_ctx_t*ctx,consttiledb_fragment_info_t*fragment_info,FILE*out);

    #ifdef__cplusplus
    }
    #endif

    #endif//TILEDB_H