Package 'tiledb'

Description

Heterogenous domains are supported, including timestamps and characters.

Usage

## S4 method for signature 'tiledb_array,ANY'
x[i, j, ..., drop = FALSE]

Arguments

Details

This function may still still change; the current implementation should be considered as an initial draft.

Value

The resulting elements in the selected format

Description

Gets a config parameter value

Usage

## S4 method for signature 'tiledb_config,ANY'
x[i, j, ..., drop = FALSE]

Arguments

Value

a config string value if parameter exists, else NA

Examples

cfg <- tiledb_config()
cfg["sm.tile_cache_size"]
cfg["does_not_exist"]

Description

Returns the filter at given index

Usage

## S4 method for signature 'tiledb_filter_list,ANY'
x[i, j, ..., drop = FALSE]

Arguments

Value

object tiledb_filter

Examples

flt <- tiledb_filter("ZSTD")
tiledb_filter_set_option(flt, "COMPRESSION_LEVEL", 5)
filter_list <- tiledb_filter_list(c(flt))
filter_list[0]

Description

This function assigns a right-hand side object, typically a data.frame or something that can be coerced to a data.frame, to a tiledb array.

Usage

## S4 replacement method for signature 'tiledb_array,ANY,ANY,ANY'
x[i, j, ...] <- value

Arguments

Details

For sparse matrices, row and column indices can either be supplied as part of the left-hand side object, or as part of the data.frame provided approrpiate column names.

This function may still still change; the current implementation should be considered as an initial draft.

Value

The modified object

Examples

## Not run: 
uri <- "quickstart_sparse"      ## as created by the other example
arr <- tiledb_array(uri)        ## open array
df <- arr[]                     ## read current content
## First approach: matching data.frame with appriate row and column
newdf <- data.frame(rows=c(1,2,2), cols=c(1,3,4), a=df$a+100)
## Second approach: supply indices explicitly
arr[c(1,2), c(1,3)] <- c(42,43) ## two values
arr[2, 4] <- 88                 ## or just one

## End(Not run)

Description

Sets a config parameter value

Usage

## S4 replacement method for signature 'tiledb_config,ANY,ANY,ANY'
x[i, j] <- value

Arguments

Value

updated tiledb_config object

Examples

cfg <- tiledb_config()
cfg["sm.tile_cache_size"]

# set tile cache size to custom value
cfg["sm.tile_cache_size"] <- 100
cfg["sm.tile_cache_size"]

Description

Returns logical value whether the array schema allows duplicate values or not. This is only valid for sparse arrays.

Usage

allows_dups(x)

## S4 method for signature 'tiledb_array_schema'
allows_dups(x)

tiledb_array_schema_get_allows_dups(x)

Arguments

Value

the logical value

Description

Sets toggle whether the array schema allows duplicate values or not. This is only valid for sparse arrays.

Usage

allows_dups(x) <- value

## S4 replacement method for signature 'tiledb_array_schema'
allows_dups(x) <- value

tiledb_array_schema_set_allows_dups(x, value)

Arguments

Value

the tiledb_array_schema object

Description

This function invokes a consolidation operation. Parameters affecting the operation can be set via an optional configuration object. Start and end timestamps can also be set directly.

Usage

array_consolidate(
  uri,
  cfg = NULL,
  start_time,
  end_time,
  ctx = tiledb_get_context()
)

Arguments

Value

NULL is returned invisibly

Description

This function can remove fragments following a consolidation step. Note that vacuuming should not be run if one intends to use the TileDB time-traveling feature of opening arrays at particular timestamps.

Usage

array_vacuum(uri, cfg = NULL, start_time, end_time, ctx = tiledb_get_context())

Arguments

Details

Parameters affecting the operation can be set via an optional configuration object. Start and end timestamps can also be set directly.

Value

NULL is returned invisibly

Description

Convert a tiledb_config object to a R data.frame

Usage

## S3 method for class 'tiledb_config'
as.data.frame(x, ...)

Arguments

Value

a data.frame wth parameter, value columns

Examples

cfg <- tiledb_config()
as.data.frame(cfg)

Description

Convert a tiledb_config object to a R vector

Usage

## S3 method for class 'tiledb_config'
as.vector(x, mode = "any")

Arguments

Value

a character vector of config parameter names, values

Examples

cfg <- tiledb_config()
as.vector(cfg)

Description

Returns a list of all tiledb_attr objects associated with the tiledb_array_schema

Usage

## S4 method for signature 'tiledb_array_schema,ANY'
attrs(object, idx, ...)

Arguments

Value

a list of tiledb_attr objects

Examples

dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 10L), type = "INT32")))
sch <- tiledb_array_schema(dom, attrs = c(tiledb_attr("a1", type = "INT32"),
                                               tiledb_attr("a2", type = "FLOAT64")))
attrs(sch)

lapply(attrs(sch), datatype)

Description

Returns a tiledb_attr object associated with the tiledb_array_schema with a given name.

Usage

## S4 method for signature 'tiledb_array_schema,character'
attrs(object, idx, ...)

Arguments

Value

a tiledb_attr object

Examples

dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 10L), type = "INT32")))
sch <- tiledb_array_schema(dom, attrs = c(tiledb_attr("a1", type = "INT32"),
                                               tiledb_attr("a2", type = "FLOAT64")))
attrs(sch, "a2")

Description

The attribute index is defined by the order the attributes were defined in the schema

Usage

## S4 method for signature 'tiledb_array_schema,numeric'
attrs(object, idx, ...)

Arguments

Value

a tiledb_attr object

Examples

dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 10L), type = "INT32")))
sch <- tiledb_array_schema(dom, attrs = c(tiledb_attr("a1", type = "INT32"),
                                          tiledb_attr("a2", type = "FLOAT64")))
attrs(sch, 2)

Description

By default, all attributes will be selected. But if a subset of attribute names is assigned to the internal slot attrs, then only those attributes will be queried. This methods accesses the slot.

Usage

## S4 method for signature 'tiledb_array,ANY'
attrs(object)

Arguments

Value

An empty character vector if no attributes have been selected or else a vector with attributes; NA means no attributes will be returned.

Description

Selects attributes for the given TileDB array

Usage

## S4 replacement method for signature 'tiledb_array'
attrs(x) <- value

Arguments

Value

The modified tiledb_array object

Description

Returns the tiledb_array schema tile capacity for sparse fragments.

Usage

capacity(object)

## S4 method for signature 'tiledb_array_schema'
capacity(object)

tiledb_array_schema_get_capacity(object)

Arguments

Value

The tile capacity value

Description

Sets the tiledb_array schema tile capacity for sparse fragments.

Usage

capacity(x) <- value

## S4 replacement method for signature 'tiledb_array_schema'
capacity(x) <- value

tiledb_array_schema_set_capacity(x, value)

Arguments

Value

The modified array_schema object

Description

Returns the cell layout string associated with the tiledb_array_schema

Usage

## S4 method for signature 'tiledb_array_schema'
cell_order(object)

Arguments

Description

Return the number of scalar values per attribute cell

Usage

cell_val_num(object)

## S4 method for signature 'tiledb_attr'
cell_val_num(object)

tiledb_attribute_get_cell_val_num(object)

Arguments

Value

integer number of cells

Examples

a1 <- tiledb_attr("a1", type = "FLOAT64", ncells = 1)
cell_val_num(a1)

Description

Return the number of scalar values per dimension cell

Usage

## S4 method for signature 'tiledb_dim'
cell_val_num(object)

tiledb_dim_get_cell_val_num(object)

Arguments

Value

integer number of cells

Description

Set the number of scalar values per attribute cell

Usage

cell_val_num(x) <- value

## S4 replacement method for signature 'tiledb_attr'
cell_val_num(x) <- value

tiledb_attribute_set_cell_val_num(x, value)

Arguments

Value

The modified attribute is returned

Description

Batched queries return an initial result set even when it is incomplete. Where the normal retrieval process will loop in place to complete a (potentially large) result set, this function will return a result (which may be part of a larger result set) allowing the user to assemble all part.

Usage

completedBatched(obj)

Arguments

Value

A logical value to indicated if the query completed

Description

Retrieve the tiledb_config object from the tiledb_ctx

Usage

## S4 method for signature 'tiledb_ctx'
config(object = tiledb_get_context())

Arguments

Value

tiledb_config object associated with the tiledb_ctx instance

Examples

ctx <- tiledb_ctx(c("sm.tile_cache_size" = "10"))
cfg <- config(ctx)
cfg["sm.tile_cache_size"]

Description

Batched queries return an initial result set even when it is incomplete. Where the normal retrieval process will loop in place to complete a (potentially large) result set, this function will return a result (which may be part of a larger result set) allowing the user to assemble all part.

Usage

createBatched(x)

Arguments

Details

The tiledb_array object can be parameterised as usual.

Value

A batchedquery object, that is a list containing an external pointer to a TileDB Query object along with other support variables used by fetchBatched

Description

Return the tiledb_attr datatype

Usage

## S4 method for signature 'tiledb_attr'
datatype(object)

Arguments

Value

tiledb datatype string

Examples

a1 <- tiledb_attr("a1", type = "INT32")
datatype(a1)

a2 <- tiledb_attr("a1", type = "FLOAT64")
datatype(a2)

Description

Return the tiledb_dim datatype

Usage

## S4 method for signature 'tiledb_dim'
datatype(object)

Arguments

Value

tiledb datatype string

Examples

d1 <- tiledb_dim("d1", domain = c(5L, 10L), tile = 2L, type = "INT32")
datatype(d1)

Description

Returns the tiledb_domain TileDB type string

Usage

## S4 method for signature 'tiledb_domain'
datatype(object)

Arguments

Value

tiledb_domain type string

Examples

dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 100L), type = "INT32")))
datatype(dom)
dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(0.5, 100.0), type = "FLOAT64")))
datatype(dom)

Description

A tiledb_array object may contain date and datetime objects. While their internal representation is generally shielded from the user, it can useful to access them as the ‘native’ format which is an integer64. This function retrieves the current value of the selection variable, which has a default of FALSE.

Usage

datetimes_as_int64(object)

## S4 method for signature 'tiledb_array'
datetimes_as_int64(object)

Arguments

Value

A logical value indicating whether datetimes_as_int64 is selected

Description

A tiledb_array object may contain date and datetime objects. While their internal representation is generally shielded from the user, it can useful to access them as the ‘native’ format which is an integer64. This function set the current value of the selection variable, which has a default of FALSE.

Usage

datetimes_as_int64(x) <- value

## S4 replacement method for signature 'tiledb_array'
datetimes_as_int64(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

Describe a TileDB array schema via code to create it

Usage

describe(arr)

Arguments

Value

Nothing is returned as the function is invoked for the side effect of printing the schema via a sequence of R instructions to re-create it.

Description

Only valid for integral (integer) domains

Usage

## S3 method for class 'tiledb_array_schema'
dim(x)

Arguments

Value

a dimension vector

Examples

dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 10L), type = "INT32")))
sch <- tiledb_array_schema(dom, attrs = c(tiledb_attr("a1", type = "INT32"),
                                          tiledb_attr("a2", type = "FLOAT64")))
dim(sch)

Description

Retrieves the dimension of the tiledb_dim domain

Usage

## S3 method for class 'tiledb_dim'
dim(x)

Arguments

Value

a vector of the tile_dim domain type, of the dim domain dimension (extent)

Examples

d1 <- tiledb_dim("d1", c(1L, 10L), 5L)
dim(d1)

Description

Only valid for integral (integer) domains

Usage

## S3 method for class 'tiledb_domain'
dim(x)

Arguments

Value

dimension vector

Examples

dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 100L), type = "INT32"),
                              tiledb_dim("d2", c(1L, 100L), type = "INT32")))
dim(dom)

Description

Returns a list of tiledb_dim objects associated with the tiledb_array_schema

Usage

## S4 method for signature 'tiledb_array_schema'
dimensions(object)

Arguments

Value

a list of tiledb_dim objects

Examples

dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 100L), type = "INT32"),
                              tiledb_dim("d2", c(1L, 50L), type = "INT32")))
sch <- tiledb_array_schema(dom, attrs = c(tiledb_attr("a1", type = "INT32")))
dimensions(dom)

lapply(dimensions(dom), name)

Description

Returns a list of the tiledb_domain dimension objects

Usage

## S4 method for signature 'tiledb_domain'
dimensions(object)

Arguments

Value

a list of tiledb_dim

Examples

dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 100L), type = "INT32"),
                              tiledb_dim("d2", c(1L, 50L), type = "INT32")))
dimensions(dom)

lapply(dimensions(dom), name)

Description

Returns the tiledb_domain object associated with a given tiledb_array_schema

Usage

## S4 method for signature 'tiledb_array_schema'
domain(object)

Arguments

Examples

dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 10L), type = "INT32")))
sch <- tiledb_array_schema(dom, attrs = c(tiledb_attr("a1", type = "INT32")))
domain(sch)

Description

Return the tiledb_dim domain

Usage

## S4 method for signature 'tiledb_dim'
domain(object)

Arguments

Value

a vector of (lb, ub) inclusive domain of the dimension

Examples

d1 <- tiledb_dim("d1", domain = c(5L, 10L))
domain(d1)

Description

A tiledb_array object can be returned as data.frame. This methods returns the selection value for ‘extended’ format including row (and column, if present) indices.

Usage

extended(object)

## S4 method for signature 'tiledb_array'
extended(object)

Arguments

Value

A logical value indicating whether an extended return is selected

Description

A tiledb_array object can be returned as data.frame. This methods set the selection value for ‘extended’ format including row (and column, if present) indices.

Usage

extended(x) <- value

## S4 replacement method for signature 'tiledb_array'
extended(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

Batched queries return an initial result set even when it is incomplete. Where the normal retrieval process will loop in place to complete a (potentially large) result set, this function will return a result (which may be part of a larger result set) allowing the user to assemble all part.

Usage

fetchBatched(x, obj)

Arguments

Details

The tiledb_array object can be parameterised as usual.

Value

A data.frame object with the (potentially partial) result of a batched query

Description

Returns the offsets and coordinate filter_lists associated with the tiledb_array_schema

Usage

## S4 method for signature 'tiledb_array_schema'
filter_list(object)

Arguments

Value

a list of tiledb_filter_list objects

Description

Returns the TileDB Filter List object associated with the given TileDB Attribute

Usage

## S4 method for signature 'tiledb_attr'
filter_list(object)

Arguments

Value

a tiledb_filter_list object

Examples

attr <- tiledb_attr(type = "INT32", filter_list=tiledb_filter_list(list(tiledb_filter("ZSTD"))))
filter_list(attr)

Description

Returns the TileDB Filter List object associated with the given TileDB Dimension

Usage

## S4 method for signature 'tiledb_dim'
filter_list(object)

Arguments

Value

A TileDB_filter_list object

Description

Sets the TileDB Filter List for the TileDB Attribute object

Usage

## S4 replacement method for signature 'tiledb_attr'
filter_list(x) <- value

Arguments

Value

The modified TileDB Attribute object

Description

Sets the TileDB Filter List for the TileDB Dimension object

Usage

## S4 replacement method for signature 'tiledb_dim'
filter_list(x) <- value

Arguments

Value

The modified TileDB Dimension object

Description

The supplied data.frame object is (currently) limited to integer, numeric, or character. In addition, three datetime columns are supported with the R representations of Date, POSIXct and nanotime.

Usage

fromDataFrame(
  obj,
  uri,
  col_index = NULL,
  sparse = TRUE,
  allows_dups = sparse,
  cell_order = "COL_MAJOR",
  tile_order = "COL_MAJOR",
  filter = "ZSTD",
  capacity = 10000L,
  tile_domain = NULL,
  tile_extent = NULL,
  mode = c("ingest", "schema_only", "append"),
  filter_list = NULL,
  coords_filters = "ZSTD",
  offsets_filters = "ZSTD",
  validity_filters = "RLE",
  debug = FALSE
)

Arguments

Details

The created (dense or sparse) array will have as many attributes as there are columns in the data.frame. Each attribute will be a single column. For a sparse array, one or more columns have to be designated as dimensions.

At present, factor variable are converted to character.

Value

Null, invisibly.

Examples

uri <- tempfile()
fromDataFrame(iris, uri)
arr <- tiledb_array(uri, return_as="data.frame", extended=FALSE)
newdf <- arr[]
all.equal(iris, newdf, check.attributes=FALSE)  # extra attribute on query in newdf
all.equal(as.matrix(iris), as.matrix(newdf))	# also strips attribute

Description

The functions fromMatrix and toMatrix help in storing (and retrieving) matrices using a TileDB backend. In particular they help for matrices with explicit rownames.

Usage

fromMatrix(obj, uri, filter = "ZSTD", capacity = 10000L)

toMatrix(uri)

Arguments

Value

Null, invisibly.

Description

The functions fromSparseMatrix and toSparseMatrix help in storing (and retrieving) sparse matrices using a TileDB backend.

Usage

fromSparseMatrix(
  obj,
  uri,
  cell_order = "ROW_MAJOR",
  tile_order = "ROW_MAJOR",
  filter = "ZSTD",
  capacity = 10000L
)

toSparseMatrix(uri)

Arguments

Value

Null, invisibly.

Examples

## Not run: 
if (requireNamespace("Matrix", quietly=TRUE)) {
    library(Matrix)
    set.seed(123)      # just to fix it
    mat <- matrix(0, nrow=20, ncol=10)
    mat[sample(seq_len(200), 20)] <- seq(1, 20)
    spmat <- as(mat, "dgTMatrix")  # sparse matrix in dgTMatrix format
    uri <- "sparse_matrix"
    fromSparseMatrix(spmat, uri)   # now written
    chk <- toSparseMatrix(uri)     # and re-read
    print(chk)
    all.equal(spmat, chk)
}

## End(Not run)

Description

Definition of generic methods

Usage

schema(object, ...)

return.data.frame(object, ...)

return.data.frame(x) <- value

attrs(x) <- value

raw_dump(object, ...)

domain(object, ...)

dimensions(object, ...)

attrs(object, idx, ...)

cell_order(object, ...)

tile_order(object, ...)

filter_list(object, ...)

filter_list(x) <- value

is.sparse(object, ...)

tiledb_ndim(object, ...)

name(object)

datatype(object)

config(object, ...)

tile(object)

is.integral(object)

nfilters(object)

tdb_filter(x, ...)

tdb_select(x, ...)

tdb_collect(x, ...)

Arguments

Description

Check a schema for a given attribute name

Usage

has_attribute(schema, attr)

Arguments

Value

A boolean value indicating if the attribute exists in the schema

Description

A TileDB attribute is anonymous if no name/label is defined

Usage

is.anonymous(object)

## S3 method for class 'tiledb_attr'
is.anonymous(object)

Arguments

Value

TRUE or FALSE

Examples

a1 <- tiledb_attr("a1", type = "FLOAT64")
is.anonymous(a1)

a2 <- tiledb_attr("", type = "FLOAT64")
is.anonymous(a2)

Description

A TileDB dimension is anonymous if no name/label is defined

Usage

## S3 method for class 'tiledb_dim'
is.anonymous(object)

Arguments

Value

TRUE or FALSE

Examples

d1 <- tiledb_dim("d1", c(1L, 10L), 10L)
is.anonymous(d1)

d2 <- tiledb_dim("", c(1L, 10L), 10L)
is.anonymous(d2)

Description

Returns TRUE is tiledb_domain is an integral (integer) domain

Usage

## S4 method for signature 'tiledb_domain'
is.integral(object)

Arguments

Value

TRUE if the domain is an integral domain, else FALSE

Examples

dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 100L), type = "INT32")))
is.integral(dom)
dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(0.5, 100.0), type = "FLOAT64")))
is.integral(dom)

Description

Returns TRUE if the tiledb_array_schema is sparse, else FALSE

Usage

## S4 method for signature 'tiledb_array_schema'
is.sparse(object)

Arguments

Value

TRUE if tiledb_array_schema is sparse

Description

By default, TileDB will use all available cores on a given machine. In multi-user or multi-process settings, one may want to reduce the number of core. This function will take a given number, or default to smaller of the ‘Ncpus’ options value or the ‘"OMP_THREAD_LIMIT"’ enviroment variable (or two as hard fallback).

Usage

limitTileDBCores(ncores, verbose = FALSE)

Arguments

Details

As this function returns a config object, its intended use is as argument to the context creating functions: ctx <- tiledb_ctx(limitTileDBCores()). To check that the values are set (or at a later point, still set) the config object should be retrieved via the corresponding method and this ctx object: cfg <- config(ctx).

Value

The modified configuration object is returned invisibly.

Description

Returns the filter_list's max_chunk_size

Usage

max_chunk_size(object)

## S4 method for signature 'tiledb_filter_list'
max_chunk_size(object)

tiledb_filter_list_get_max_chunk_size(object)

Arguments

Value

integer max_chunk_size

Examples

flt <- tiledb_filter("ZSTD")
tiledb_filter_set_option(flt, "COMPRESSION_LEVEL", 5)
filter_list <- tiledb_filter_list(c(flt))
max_chunk_size(filter_list)

Description

Return the tiledb_attr name

Usage

## S4 method for signature 'tiledb_attr'
name(object)

Arguments

Value

string name, empty string if the attribute is anonymous

Examples

a1 <- tiledb_attr("a1", type = "INT32")
name(a1)

a2 <- tiledb_attr(type = "INT32")
name(a2)

Description

Return the tiledb_dim name

Usage

## S4 method for signature 'tiledb_dim'
name(object)

Arguments

Value

string name, empty string if the dimension is anonymous

Examples

d1 <- tiledb_dim("d1", c(1L, 10L))
name(d1)

d2 <- tiledb_dim("", c(1L, 10L))
name(d2)

Description

Returns the filter_list's number of filters

Usage

## S4 method for signature 'tiledb_filter_list'
nfilters(object)

Arguments

Value

integer number of filters

Examples

flt <- tiledb_filter("ZSTD")
tiledb_filter_set_option(flt, "COMPRESSION_LEVEL", 5)
filter_list <- tiledb_filter_list(c(flt))
nfilters(filter_list)

Description

The grammar for query conditions is at present constraint to eight operators (">", ">=", "<", "<=", "==", "!=", "%in%", "%nin%"), and three boolean operators ("&&", also as "&", ("||", also as "|", and "!" for negation. Note that we locally define "%nin%" as Negate() call around %in%) which extends R a little for this use case.

Usage

parse_query_condition(
  expr,
  ta = NULL,
  debug = FALSE,
  strict = TRUE,
  use_int64 = FALSE
)

Arguments

Details

Expressions are parsed locally by this function. The debug=TRUE option may help if an issue has to be diagnosed. In most cases of an errroneous parse, it generally helps to supply the tiledb_array providing schema information. One example are numeric and integer columns where the data type is difficult to guess. Also, when using the "%in%" or "%nin%" operators, the argument is mandatory.

Value

A tiledb_query_condition object

Examples

## Not run: 
uri <- "mem://airquality"    # change to on-disk for persistence
fromDataFrame(airquality, uri, col_index=c("Month", "Day"))  # dense array
## query condition on dense array requires extended=FALSE
tiledb_array(uri, return_as="data.frame", extended=FALSE,
             query_condition=parse_query_condition(Temp > 90))[]

## End(Not run)

Description

Print a TileDB Array Metadata object

Usage

## S3 method for class 'tiledb_metadata'
print(x, width = NULL, ...)

Arguments

Value

The array object, invisibly

Description

A tiledb_array object can have a corresponding query condition object. This methods returns it.

Usage

query_condition(object)

## S4 method for signature 'tiledb_array'
query_condition(object)

Arguments

Value

A tiledb_query_condition object

Description

A tiledb_array object can have an associated query condition object to set conditions on the read queries. This methods sets the ‘query_condition’ object.

Usage

query_condition(x) <- value

## S4 replacement method for signature 'tiledb_array'
query_condition(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

A tiledb_array object can have a corresponding query with a given layout given layout. This methods returns the selection value for ‘query_layout’ as a character value.

Usage

query_layout(object)

## S4 method for signature 'tiledb_array'
query_layout(object)

Arguments

Value

A character value describing the query layout

Description

A tiledb_array object can have an associated query with a specific layout. This methods sets the selection value for ‘query_layout’ from a character value.

Usage

query_layout(x) <- value

## S4 replacement method for signature 'tiledb_array'
query_layout(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

A tiledb_array object can, if requested, return query statistics as a JSON string in an attribute ‘query_statistics’ attached to the return object. The default value of the logical switch is ‘FALSE’. This method returns the current value.

Usage

query_statistics(object, ...)

## S4 method for signature 'tiledb_array'
query_statistics(object)

Arguments

Value

A logical value indicating whether query statistics are returned.

Description

A tiledb_array object can, if requested, return query statistics as a JSON string in an attribute ‘query_statistics’ attached to the return object. The default value of the logical switch is ‘FALSE’. This method sets the value.

Usage

query_statistics(x) <- value

## S4 replacement method for signature 'tiledb_array'
query_statistics(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

Look up TileDB type corresponding to the type of an R object

Usage

r_to_tiledb_type(x)

Arguments

Value

single character, e.g. INT32

Description

This method used the display method provided by the underlying library.

Usage

## S4 method for signature 'tiledb_array_schema'
raw_dump(object)

Arguments

Description

This method used the display method provided by the underlying library.

Usage

## S4 method for signature 'tiledb_attr'
raw_dump(object)

Arguments

Description

This method used the display method provided by the underlying library.

Usage

## S4 method for signature 'tiledb_domain'
raw_dump(object)

Arguments

Description

A tiledb_array object can be returned as a ‘list’ (default), ‘array’, ‘matrix’, ‘data.frame’, ‘data.table’ or ‘tibble’. This method permits to select a preference for the returned object. The default value of ‘asis’ means that no conversion is performed.

Usage

return_as(object, ...)

## S4 method for signature 'tiledb_array'
return_as(object)

Arguments

Value

A character value indicating the preferred conversion where the value is one of ‘asis’ (the default), ‘array’, ‘matrix’,‘data.frame’, ‘data.table’, or ‘tibble’.

Description

A tiledb_array object can be returned as a ‘list’ (default), ‘array’, ‘matrix’, ‘data.frame’, ‘data.table’ or ‘tibble’. This method This methods permits to set a preference of returning a list, array, matrix, data.frame, a data.table, or a tibble. The default value of “asis” means that no conversion is performed and a list is returned.

Usage

return_as(x) <- value

## S4 replacement method for signature 'tiledb_array'
return_as(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

A tiledb_array object can be returned as an array (or list of arrays), or, if select, as a data.frame or as a matrix. This methods returns the selection value for the array selection.

Usage

return.array(object, ...)

## S4 method for signature 'tiledb_array'
return.array(object)

Arguments

Value

A logical value indicating whether array return is selected

Description

A tiledb_array object can be returned as an array (or list of arrays), or, if select, as a data.frame or a matrix. This methods sets the selection value for a array.

Usage

return.array(x) <- value

## S4 replacement method for signature 'tiledb_array'
return.array(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

A tiledb_array object can be returned as an array (or list of arrays), or, if select, as a data.frame. This methods returns the selection value.

Usage

## S4 method for signature 'tiledb_array'
return.data.frame(object)

Arguments

Value

A logical value indicating whether data.frame return is selected

Description

A tiledb_array object can be returned as an array (or list of arrays), or, if select, as a data.frame. This methods sets the selection value.

Usage

## S4 replacement method for signature 'tiledb_array'
return.data.frame(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

A tiledb_array object can be returned as an array (or list of arrays), or, if select, as a data.frame or as a matrix. This methods returns the selection value for the matrix selection.

Usage

return.matrix(object, ...)

## S4 method for signature 'tiledb_array'
return.matrix(object)

Arguments

Value

A logical value indicating whether matrix return is selected

Description

A tiledb_array object can be returned as an array (or list of arrays), or, if select, as a data.frame or a matrix. This methods sets the selection value for a matrix.

Usage

return.matrix(x) <- value

## S4 replacement method for signature 'tiledb_array'
return.matrix(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

Save (or load) allocation size default preference in an optional config file

Usage

save_allocation_size_preference(value)

load_allocation_size_preference()

get_allocation_size_preference()

set_allocation_size_preference(value)

Arguments

Details

When retrieving data from sparse arrays, allocation sizes cannot be determined ex ante as the degree of sparsity is unknown. A configuration value can aide in providing an allocation size value. These functions let the user store such a value for retrieval by their package or script code. The preference will be encoded in a configuration file as R (version 4.0.0 or later) allows a user- and package specific configuration files. These helper functions sets and retrieve the value, respectively, or retrieve the cached value from the package environment where is it set at package load.

The value will be stored as a character value and reparsed so ‘1e6’ and ‘1000000’ are equivalent, and the fixed (but adjustable) number of digits for numerical precision use for formatting will impact the writing. This should have no effect on standard allocation sizes.

The value is used as a limit per column so total memory use per query will a multiple of this value, and increasing in dimension and attribute count.

A fallback value of 10 mb is used if no user value is set.

Value

For the setter, TRUE is returned invisibly but the function is invoked for the side effect of storing the value. For the getters, the value as a numeric.

Note

This function requires R version 4.0.0 or later to utilise the per-user config directory accessor function. For older R versions, a fallback from the TileDB configuration object is used.

Description

Save (or load) ‘return_as’ conversion preference in an optional config file

Usage

save_return_as_preference(
  value = c("asis", "array", "matrix", "data.frame", "data.table", "tibble")
)

load_return_as_preference()

get_return_as_preference()

set_return_as_preference(
  value = c("asis", "array", "matrix", "data.frame", "data.table", "tibble")
)

Arguments

Details

The tiledb_array object can set a preference for conversion for each retrieved object. This preference can also be enconded in a configuration file as R (version 4.0.0 or later) allows a user- and package specific configuration files. These helper functions sets and retrieve the value, respectively, or retrieve the cached value from the package environment where is it set at package load.

Note that the value must be one of ‘asis’ (the default), ‘array’, ‘matrix’‘data.frame’, ‘data.table’ or ‘tibble’. The latter two require the corresponding package to be installed.

Value

For the setter, TRUE is returned invisibly but the function is invoked for the side effect of storing the value. For either getter, the character value.

Note

This function requires R version 4.0.0 or later to utilise the per-user config directory accessor function. For older R versions, please set the attribute directly when creating the tiledb_array object, or via the return_as() method.

Description

Returns the tiledb_array schema for correctness

Usage

schema_check(object)

## S4 method for signature 'tiledb_array_schema'
schema_check(object)

check(object)

## S4 method for signature 'tiledb_array_schema'
check(object)

tiledb_array_schema_check(object)

Arguments

Value

The boolean value TRUE is returned for a correct schema; for an incorrect schema an error condition is triggered.

Description

Return a schema from a URI character value

Usage

## S4 method for signature 'character'
schema(object, ...)

Arguments

Value

The scheme for the object

Description

Return a schema from a tiledb_array object

Usage

## S4 method for signature 'tiledb_array'
schema(object, ...)

Arguments

Value

The scheme for the object

Description

A tiledb_array object can have a range selection for each dimension attribute. This methods returns the selection value for ‘selected_points’ and returns a list (with one element per dimension) of vectors where each row describes one selected points. Alternatively, the list can be named with the names providing the match to the corresponding dimension.

Usage

selected_points(object)

## S4 method for signature 'tiledb_array'
selected_points(object)

Arguments

Value

A list which can contain a vector for each dimension

Description

A tiledb_array object can have a range selection for each dimension attribute. This methods sets the selection value for ‘selected_points’ which is a list (with one element per dimension) of two-column matrices where each row describes one pair of minimum and maximum values. Alternatively, the list can be named with the names providing the match to the corresponding dimension.

Usage

selected_points(x) <- value

## S4 replacement method for signature 'tiledb_array'
selected_points(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

A tiledb_array object can have a range selection for each dimension attribute. This methods returns the selection value for ‘selected_ranges’ and returns a list (with one element per dimension) of two-column matrices where each row describes one pair of minimum and maximum values. Alternatively, the list can be named with the names providing the match to the corresponding dimension.

Usage

selected_ranges(object)

## S4 method for signature 'tiledb_array'
selected_ranges(object)

Arguments

Value

A list which can contain a matrix for each dimension

Description

A tiledb_array object can have a range selection for each dimension attribute. This methods sets the selection value for ‘selected_ranges’ which is a list (with one element per dimension) of two-column matrices where each row describes one pair of minimum and maximum values. Alternatively, the list can be named with the names providing the match to the corresponding dimension.

Usage

selected_ranges(x) <- value

## S4 replacement method for signature 'tiledb_array'
selected_ranges(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

Set the filter_list's max_chunk_size

Usage

set_max_chunk_size(object, value)

## S4 method for signature 'tiledb_filter_list,numeric'
set_max_chunk_size(object, value)

tiledb_filter_list_set_max_chunk_size(object, value)

Arguments

Examples

flt <- tiledb_filter("ZSTD")
tiledb_filter_set_option(flt, "COMPRESSION_LEVEL", 5)
filter_list <- tiledb_filter_list(c(flt))
set_max_chunk_size(filter_list, 10)

Description

Prints an array schema object

Usage

## S4 method for signature 'tiledb_array_schema'
show(object)

Arguments

Description

Prints a tiledb_array object

Usage

## S4 method for signature 'tiledb_array'
show(object)

Arguments

Description

Prints an attribute object

Usage

## S4 method for signature 'tiledb_attr'
show(object)

Arguments

Description

Prints the config object to STDOUT

Usage

## S4 method for signature 'tiledb_config'
show(object)

Arguments

Examples

cfg <- tiledb_config()
show(cfg)

Description

Prints a dimension object

Usage

## S4 method for signature 'tiledb_dim'
show(object)

Arguments

Description

Prints a domain object

Usage

## S4 method for signature 'tiledb_domain'
show(object)

Arguments

Description

Prints a filter_list object

Usage

## S4 method for signature 'tiledb_filter_list'
show(object)

Arguments

Description

Prints a filter object

Usage

## S4 method for signature 'tiledb_filter'
show(object)

Arguments

Description

Display the TileDB Group object to STDOUT

Usage

## S4 method for signature 'tiledb_group'
show(object)

Arguments

Description

Batched queries return an initial result set even when it is incomplete. Where the normal retrieval process will loop in place to complete a (potentially large) result set, this function will return a result (which may be part of a larger result set) allowing the user to assemble all part.

Usage

statusBatched(obj)

Arguments

Value

The Query status as a character variable

Description

A tiledb_array object containing character column can have those converted to factors variables. This methods returns the selection value for ‘strings_as_factors’.

Usage

strings_as_factors(object)

## S4 method for signature 'tiledb_array'
strings_as_factors(object)

Arguments

Value

A logical value indicating whether an strings_as_factors return is selected

Description

A tiledb_array object containing character column can have those converted to factors variables. This methods sets the selection value for ‘strings_as_factors’.

Usage

strings_as_factors(x) <- value

## S4 replacement method for signature 'tiledb_array'
strings_as_factors(x) <- value

Arguments

Value

The modified tiledb_array array object

Description

Collect the query results to finalize piped expression

Usage

## S4 method for signature 'tiledb_array'
tdb_collect(x, ...)

Arguments

Value

The object returning from a tiledb_array query (the type of which can be set via the return preference mechanism, see the help for "[" accessor)

Description

Filter from array for query via logical conditions

Usage

## S4 method for signature 'tiledb_array'
tdb_filter(x, ..., strict = TRUE)

Arguments

Value

The tiledb_array object, permitting piping

Description

Select attributes from array for query

Usage

## S4 method for signature 'tiledb_array'
tdb_select(x, ...)

Arguments

Value

The tiledb_array object, permitting piping

Description

Returns the tile layout string associated with the tiledb_array_schema

Usage

## S4 method for signature 'tiledb_array_schema'
tile_order(object)

Arguments

Description

Return the tiledb_dim tile extent

Usage

## S4 method for signature 'tiledb_dim'
tile(object)

Arguments

Value

a scalar tile extent

Examples

d1 <- tiledb_dim("d1", domain = c(5L, 10L), tile = 2L)
tile(d1)

Description

tiledb_array returns a new object. This class is experimental.

Usage

tiledb_array(
  uri,
  query_type = c("READ", "WRITE"),
  is.sparse = NA,
  as.data.frame = FALSE,
  attrs = character(),
  extended = TRUE,
  selected_ranges = list(),
  selected_points = list(),
  query_layout = character(),
  datetimes_as_int64 = FALSE,
  encryption_key = character(),
  as.matrix = FALSE,
  as.array = FALSE,
  query_condition = new("tiledb_query_condition"),
  timestamp_start = as.POSIXct(double(), origin = "1970-01-01"),
  timestamp_end = as.POSIXct(double(), origin = "1970-01-01"),
  return_as = get_return_as_preference(),
  query_statistics = FALSE,
  strings_as_factors = getOption("stringsAsFactors", FALSE),
  keep_open = FALSE,
  sil = list(),
  dumpbuffers = character(),
  buffers = list(),
  ctx = tiledb_get_context()
)

tiledb_dense(...)

tiledb_sparse(...)

Arguments

Value

tiledb_array object

Description

For dense arrays, use tiledb_query_apply_aggregate after setting an appropriate subarray.

Usage

tiledb_array_apply_aggregate(
  array,
  attrname,
  operation = c("Count", "NullCount", "Min", "Max", "Mean", "Sum"),
  nullable = TRUE
)

Arguments

Value

The value of the aggregation

Description

Close a TileDB Array

Usage

tiledb_array_close(arr)

Arguments

Value

The TileDB Array object but closed

Description

Creates a new TileDB array given an input schema.

Usage

tiledb_array_create(uri, schema, encryption_key)

Arguments

Examples

## Not run: 
pth <- tempdir()
dom <- tiledb_domain(dims = c(tiledb_dim("d1", c(1L, 10L), type = "INT32")))
sch <- tiledb_array_schema(dom, attrs = c(tiledb_attr("a1", type = "INT32")))
tiledb_array_create(pth, sch)
tiledb_object_type(pth)

## End(Not run)

Description

Delete fragments written between the start and end times given

Usage

tiledb_array_delete_fragments(
  arr,
  ts_start,
  ts_end,
  ctx = tiledb_get_context()
)

Arguments

Value

A boolean indicating success

Description

This functions works for both fixed- and variable-sized dimensions and switches internally.

Usage

tiledb_array_get_non_empty_domain_from_index(arr, idx)

Arguments

Value

A two-element object is returned describing the domain of selected dimension; it will either be a numeric vector in case of a fixed-size fixed-sized dimensions, or a characer vector for a variable-sized one.

Description

This functions works for both fixed- and variable-sized dimensions and switches internally.

Usage

tiledb_array_get_non_empty_domain_from_name(arr, name)

Arguments

Value

A two-element object is returned describing the domain of selected dimension; it will either be a numeric vector in case of a fixed-size fixed-sized dimensions, or a characer vector for a variable-sized one.

Description

Check for Enumeration (aka Factor aka Dictionary)

Usage

tiledb_array_has_enumeration(arr)

Arguments

Value

A boolean indicating if the array has homogeneous domains

Description

Check for Heterogeneous Domain

Usage

tiledb_array_is_heterogeneous(arr)

Arguments

Value

A boolean indicating if the array has heterogenous domains

Description

Check for Homogeneous Domain

Usage

tiledb_array_is_homogeneous(arr)

Arguments

Value

A boolean indicating if the array has homogeneous domains

Description

Test if TileDB Array is open

Usage

tiledb_array_is_open(arr)

Arguments

Value

A boolean indicating whether the TileDB Array object is open

Description

Open a TileDB Array

Usage

tiledb_array_open(
  arr,
  type = if (tiledb_version(TRUE) >= "2.12.0") c("READ", "WRITE", "DELETE",
    "MODIFY_EXCLUSIVE") else c("READ", "WRITE")
)

Arguments

Value

The TileDB Array object but opened for reading or writing

Description

Open a TileDB Array at Timestamp

Usage

tiledb_array_open_at(arr, type = c("READ", "WRITE"), timestamp)

Arguments

Value

The TileDB Array object but opened for reading or writing

Description

Constructs a tiledb_array_schema object

Usage

tiledb_array_schema(
  domain,
  attrs,
  cell_order = "COL_MAJOR",
  tile_order = "COL_MAJOR",
  sparse = FALSE,
  coords_filter_list = NULL,
  offsets_filter_list = NULL,
  validity_filter_list = NULL,
  capacity = 10000L,
  allows_dups = FALSE,
  enumerations = NULL,
  ctx = tiledb_get_context()
)

Arguments

Examples

schema <- tiledb_array_schema(
              dom = tiledb_domain(
                        dims = c(tiledb_dim("rows", c(1L, 4L), 4L, "INT32"),
                                 tiledb_dim("cols", c(1L, 4L), 4L, "INT32"))),
              attrs = c(tiledb_attr("a", type = "INT32")),
              cell_order = "COL_MAJOR",
              tile_order = "COL_MAJOR",
              sparse = FALSE)
schema

Description

Creates a 'tiledb_array_schema_evolution' object

Usage

tiledb_array_schema_evolution(ctx = tiledb_get_context())

Arguments

Value

A 'array_schema_evolution' object

Description

Add an Attribute to a TileDB Array Schema Evolution object

Usage

tiledb_array_schema_evolution_add_attribute(object, attr)

Arguments

Value

The modified 'array_schema_evolution' object, invisibly

Description

Add an Enumeration to a TileDB Array Schema Evolution object

Usage

tiledb_array_schema_evolution_add_enumeration(
  object,
  name,
  enums,
  ordered = FALSE,
  ctx = tiledb_get_context()
)

Arguments

Value

The modified 'array_schema_evolution' object, invisibly

Description

Evolve an Array Schema by adding an empty Enumeration

Usage

tiledb_array_schema_evolution_add_enumeration_empty(
  ase,
  enum_name,
  type_str = "ASCII",
  cell_val_num = NA_integer_,
  ordered = FALSE,
  ctx = tiledb_get_context()
)

Arguments

Description

Evolve an Array Schema

Usage

tiledb_array_schema_evolution_array_evolve(object, uri)

Arguments

Value

The modified 'array_schema_evolution' object, invisibly

Description

Drop an attribute given by name from a TileDB Array Schema Evolution object

Usage

tiledb_array_schema_evolution_drop_attribute(object, attrname)

Arguments

Value

The modified 'array_schema_evolution' object, invisibly

Description

Drop an Enumeration given by name from a TileDB Array Schema Evolution object

Usage

tiledb_array_schema_evolution_drop_enumeration(object, attrname)

Arguments

Value

The modified 'array_schema_evolution' object, invisibly

Description

Extend an Evolution via Array Schema Evolution

Usage

tiledb_array_schema_evolution_extend_enumeration(
  ase,
  array,
  enum_name,
  new_values,
  nullable = FALSE,
  ordered = FALSE,
  ctx = tiledb_get_context()
)

Arguments

Description

An S4 class for a TileDB ArraySchemaEvolution object

Slots

ptr

An external pointer to the underlying implementation

Description

Set a Filter List for Coordinate of a TileDB Schema

Usage

tiledb_array_schema_set_coords_filter_list(sch, fl)

Arguments

Value

The modified Array Schema object

Description

Add an empty Enumeration to a Schema

Usage

tiledb_array_schema_set_enumeration_empty(
  schema,
  attr,
  enum_name,
  type_str = "ASCII",
  cell_val_num = NA_integer_,
  ordered = FALSE,
  ctx = tiledb_get_context()
)

Arguments

Description

Set a Filter List for Variable-Sized Offsets of a TileDB Schema

Usage

tiledb_array_schema_set_offsets_filter_list(sch, fl)

Arguments

Value

The modified Array Schema object

Description

Set a Filter List for Validity of a TileDB Schema

Usage

tiledb_array_schema_set_validity_filter_list(sch, fl)

Arguments

Value

The modified Array Schema object

Description

Returns the (internal) version of the tiledb_array schema

Usage

tiledb_array_schema_version(object)

Arguments

Value

An integer value describing the internal schema format version

Description

An S4 class for the TileDB array schema

Slots

ptr

An external pointer to the underlying implementation

arrptr

An optional external pointer to the underlying array, or NULL if missing

Description

Upgrade an Array to the current TileDB Array Schema Format

Usage

tiledb_array_upgrade_version(array, config = NULL, ctx = tiledb_get_context())

Arguments

Value

Nothing is returned as the function is invoked for its side effect

Description

This class replaces the earlier (and now removed) tiledb_dense and tiledb_sparse and provides equivalent functionality based on a refactored implementation utilising newer TileDB features.

Slots

ctx

A TileDB context object

uri

A character despription with the array URI

is.sparse

A logical value whether the array is sparse or not

as.data.frame

A logical value

attrs

A character vector to select particular column ‘attributes’; default is an empty character vector implying ‘all’ columns, the special value NA_character_ has the opposite effect and selects ‘none’.

extended

A logical value, defaults to TRUE, indicating whether index columns are returned as well.

selected_ranges

An optional list with matrices where each matrix i describes the (min,max) pair of ranges for dimension i

selected_points

An optional list with vectors where each vector i describes the selected points for dimension i

query_layout

An optional character value

datetimes_as_int64

A logical value

encryption_key

A character value

as.matrix

A logical value

as.array

A logical value

query_condition

A Query Condition object

timestamp_start

A POSIXct datetime variable for the inclusive interval start

timestamp_end

A POSIXct datetime variable for the inclusive interval start

return_as

A character value with the desired tiledb_array conversion, permitted values are ‘asis’ (default, returning a list of columns), ‘array’, ‘matrix’,‘data.frame’, ‘data.table’ ‘tibble’, ‘arrow_table’ or ‘arrow’ (where the last two are synomyms); note that ‘data.table’, ‘tibble’ and ‘arrow’ require the respective packages to installed.

query_statistics

A logical value, defaults to ‘FALSE’; if ‘TRUE’ the query statistics are returned (as a JSON string) via the attribute ‘query_statistics’ of the return object.

sil

An optional and internal list object with schema information, used for parsing queries.

dumpbuffers

An optional character variable with a directory name (relative to /dev/shm) for writing out results buffers (for internal use / testing)

buffers

An optional list with full pathnames of shared memory buffers to read data from

strings_as_factors

An optional logical to convert character columns to factor type

keep_open

An optional logical to not close after read or write

ptr

External pointer to the underlying implementation

Description

These functions allocate (and free) appropriate pointer objects for, respectively, Arrow array and schema objects. These functions are deprecated and will be removed, it is recommended to rely directly on the nanoarrow replacements.

Usage

tiledb_arrow_array_ptr()

tiledb_arrow_schema_ptr()

tiledb_arrow_array_del(ptr)

tiledb_arrow_schema_del(ptr)

Arguments

Value

The allocating functions return the requested pointer

Description

Constructs a tiledb_attr object

Usage

tiledb_attr(
  name,
  type,
  filter_list = tiledb_filter_list(),
  ncells = 1,
  nullable = FALSE,
  enumeration = NULL,
  ctx = tiledb_get_context()
)

Arguments

Value

tiledb_dim object

Examples

flt <- tiledb_filter_list(list(tiledb_filter("GZIP")))
attr <- tiledb_attr(name = "a1", type = "INT32",
                    filter_list = flt)
attr

Description

An S4 class for a TileDB attribute

Slots

ptr

External pointer to the underlying implementation

Description

Get the TileDB Attribute cell size

Usage

tiledb_attribute_get_cell_size(attr)

Arguments

Value

A numeric value with the cell size

Description

Get the TileDB Attribute Enumeration

Usage

tiledb_attribute_get_enumeration(attr, arr, ctx = tiledb_get_context())

tiledb_attribute_get_enumeration_ptr(attr, arrptr, ctx = tiledb_get_context())

Arguments

Value

A character vector with the enumeration (of length zero if none)

Description

Get the fill value for a TileDB Attribute

Usage

tiledb_attribute_get_fill_value(attr)

Arguments

Value

The fill value for the attribute

Description

Get the TileDB Attribute Nullable flag value

Usage

tiledb_attribute_get_nullable(attr)

Arguments

Value

A boolean value with the ‘Nullable’ status

Description

Test if TileDB Attribute has an Enumeration

Usage

tiledb_attribute_has_enumeration(attr, ctx = tiledb_get_context())

Arguments

Value

A logical value indicating if the attribute has an enumeration

Description

Check if TileDB Attribute Enumeration is Ordered

Usage

tiledb_attribute_is_ordered_enumeration_ptr(
  attr,
  arrptr,
  ctx = tiledb_get_context()
)

Arguments

Value

A character vector with the enumeration (of length zero if none)

Description

Check whether TileDB Attribute is variable-sized

Usage

tiledb_attribute_is_variable_sized(attr)

Arguments

Value

A boolean value indicating variable-size or not

Description

Set a TileDB Attribute Enumeration Name

Usage

tiledb_attribute_set_enumeration_name(
  attr,
  enum_name,
  ctx = tiledb_get_context()
)

Arguments

Value

The modified TileDB Attribute object

Description

Set the fill value for a TileDB Attribute

Usage

tiledb_attribute_set_fill_value(attr, value)

Arguments

Value

NULL is returned invisibly

Description

Set the TileDB Attribute Nullable flags

Usage

tiledb_attribute_set_nullable(attr, flag)

Arguments

Value

Nothing is returned

Description

Note that for actually setting persistent values, the (altered) config object needs to used to create (or update) the tiledb_ctx object. Similarly, to check whether values are set, one should use the config method of the of the tiledb_ctx object. Examples for this are ctx <- tiledb_ctx(limitTileDBCores()) to use updated configuration values to create a context object, and cfg <- config(ctx) to retrieve it.

Usage

tiledb_config(config = NA_character_)

Arguments

Value

tiledb_config object

Examples

cfg <- tiledb_config()
cfg["sm.tile_cache_size"]

# set tile cache size to custom value
cfg <- tiledb_config(c("sm.tile_cache_size" = "100"))
cfg["sm.tile_cache_size"]

Description

Return the 'AsBuilt' JSON string

Usage

tiledb_config_as_built_json()

Value

The JSON string containing 'AsBuilt' information

Examples

if (tiledb_version(TRUE) > "2.17")
    txt <- tiledb::tiledb_config_as_built_json()
## now eg either one of
##   sapply(jsonlite::fromJSON(txt)$as_built$parameters$storage_backends, \(x) x[[1]])
##   sapply(RcppSimdJson::fparse(txt)$as_built$parameters$storage_backends, \(x) x[[1]])
## will return a named vector such as
##   c(azure = FALSE, gcs = FALSE, hdfs = FALSE, s3 = TRUE)

Description

Display the 'AsBuilt' JSON string

Usage

tiledb_config_as_built_show()

Value

Nothing is returned but as a side-effect the 'AsBuilt' string is displayed

Description

Load a saved tiledb_config file from disk

Usage

tiledb_config_load(path)

Arguments

Examples

tmp <- tempfile()
cfg <- tiledb_config(c("sm.tile_cache_size" = "10"))
pth <- tiledb_config_save(cfg, tmp)
cfg <- tiledb_config_load(pth)
cfg["sm.tile_cache_size"]

Description

Save a tiledb_config object ot a local text file

Usage

tiledb_config_save(config, path)

Arguments

Value

path to created config file

Examples

tmp <- tempfile()
cfg <- tiledb_config(c("sm.tile_cache_size" = "10"))
pth <- tiledb_config_save(cfg, tmp)

cat(readLines(pth), sep = "\n")

Description

Unset a TileDB Config parameter to its default value

Usage

tiledb_config_unset(config, param)

Arguments

Value

The modified TileDB Config object

Description

An S4 class for a TileDB configuration

Slots

ptr

An external pointer to the underlying implementation

Description

Creates a tiledb_ctx object

Usage

tiledb_ctx(config = NULL, cached = TRUE)

Arguments

Value

tiledb_ctx object

Examples

# default configuration
ctx <- tiledb_ctx()

# optionally set config parameters
ctx <- tiledb_ctx(c("sm.tile_cache_size" = "100"))

Description

Sets default context tags

Usage

tiledb_ctx_set_default_tags(object)

Arguments

Description

Sets a string:string "tag" on the Ctx

Usage

tiledb_ctx_set_tag(object, key, value)

Arguments

Examples

ctx <- tiledb_ctx(c("sm.tile_cache_size" = "10"))
cfg <- tiledb_ctx_set_tag(ctx, "tag", "value")

Description

Return context statistics as a JSON string

Usage

tiledb_ctx_stats(object = tiledb_get_context())

Arguments

Value

A JSON-formatted string with context statistics

Description

An S4 class for a TileDB context

Slots

ptr

An external pointer to the underlying implementation

Description

This function maps from the TileDB types to the (fewer) key datatypes in R. This can be lossy as TileDB integers range from (signed and unsigned) 8 to 64 bit whereas R only has (signed) 32 bit values. Similarly, R only has 64 bit doubles whereas TileDB has 32 and 64 bit floating point types. TileDB also has more character encodings, and the full range of (NumPy) date and time types.

Usage

tiledb_datatype_R_type(datatype)

Arguments

Value

A string describing the closest match for an R datatype

Description

Delete a TileDB Array Metadata object given by key

Usage

tiledb_delete_metadata(arr, key)

Arguments

Value

A boolean indicating success

Description

Constructs a tiledb_dim object

Usage

tiledb_dim(
  name,
  domain,
  tile,
  type,
  filter_list = tiledb_filter_list(),
  ctx = tiledb_get_context()
)