The vendored nanoarrow sources have been update to release 0.4.0, and use of its facilities has been extended (#663)
diff --git a/docs/pkgdown.yml b/docs/pkgdown.yml
index 6cc04e6eba..e565b86034 100644
--- a/docs/pkgdown.yml
+++ b/docs/pkgdown.yml
@@ -7,5 +7,5 @@ articles:
installation-options: installation-options.html
introduction: introduction.html
tiledb-mariadb-examples: tiledb-mariadb-examples.html
-last_built: 2024-03-20T19:45Z
+last_built: 2024-03-20T20:32Z
diff --git a/docs/search.json b/docs/search.json
index 28d6ddbb4c..a245d7479f 100644
--- a/docs/search.json
+++ b/docs/search.json
@@ -1 +1 @@
-[{"path":"/articles/data-ingestion-from-sql.html","id":"introduction","dir":"Articles","previous_headings":"","what":"Introduction","title":"Date Ingestion from SQL: A Commented Example","text":"TileDB provides Universal Data Engine can accessed variety ways. Users sometimes wonder transfer data existing databases. short vignettes shows example relying DBI package R. offers powerful convenient abstraction layer top number database backends connection packages adhere , utilise, DBI framework. examples packages (listed alphabetical order) duckdb, RClickhouse, RGreenplum, RJDBC, RMariaDB, RMySQL, ROracle, RPostgres, RPostgreSQL, RPresto, RRedshiftSQL, RSQLite, many seen via CRAN page. provide simple example using RPostgreSQL existing database historical stockmarket price data.","code":""},{"path":"/articles/data-ingestion-from-sql.html","id":"load-required-packages","dir":"Articles","previous_headings":"","what":"Load Required Packages","title":"Date Ingestion from SQL: A Commented Example","text":"basic setup straightforward. load required package RPostgreSQL turn imports DBI well tiledb. use data.table print method, tibble package offers alternative):","code":"library(RPostgreSQL) library(data.table) library(tiledb)"},{"path":"/articles/data-ingestion-from-sql.html","id":"connect-to-database","dir":"Articles","previous_headings":"","what":"Connect to Database","title":"Date Ingestion from SQL: A Commented Example","text":"step uses DBI abstraction. compliant backend driver can loaded via dbDriver, connection can established via dbConnect using appropriate arguments dbname, user, password, host, port, needed, proper dispatching implementation provided driver. details depend chosen backend, can simple con <- dbConnect(RSQLite::SQLite(), \":memory:\") case RSQLite -memory (likely transient) database.","code":"## a local SQL db we have here -- about 617k rows dbSetup <- function() { drv <- dbDriver(\"PostgreSQL\") con <- dbConnect(drv, user=\"...omitted...\", password=\"...omitted...\", # Could use e.g. Sys.getenv(\"DB_PASSWD\") dbname=\"...omitted...\") con }"},{"path":"/articles/data-ingestion-from-sql.html","id":"fetch-data","dir":"Articles","previous_headings":"","what":"Fetch Data","title":"Date Ingestion from SQL: A Commented Example","text":"next step fetch data—simplicity issue just one select statement returning single data.frame (data.table variant). larger--memory settings SQL query easily bucket symbols, date range, …","code":"getDataFromSQL <- function() { con <- dbSetup() sql <- \"select * from stockprices order by symbol, date;\" res <- dbGetQuery(con, sql) dbDisconnect(con) setDT(res) # create data.table res }"},{"path":"/articles/data-ingestion-from-sql.html","id":"writing-data-to-tiledb","dir":"Articles","previous_headings":"","what":"Writing Data to TileDB","title":"Date Ingestion from SQL: A Commented Example","text":"read data memory can use TileDB R function fromDataFrame. numerous option configure, well sensible defaults (example enable ZSTD compression). select first two columns symbol data dimensions. Symbols, text, set domain set. date set two ‘safe’ outer values range. mode=\"append\" argument fromDataFrame can used append existing array support chunked operation.","code":"storeDataTDB <- function(dat, uri) { fromDataFrame(dat, uri, col_index=1:2, tile_domain=list(date=c(as.numeric(as.Date(\"1985-01-01\")), as.numeric(as.Date(\"2030-12-31\"))))) }"},{"path":"/articles/data-ingestion-from-sql.html","id":"reading-data-back-in","dir":"Articles","previous_headings":"Writing Data to TileDB","what":"Reading Data Back In","title":"Date Ingestion from SQL: A Commented Example","text":"Reading data TileDB standard operation opening URI, possibly specifying return type possibly subsetting dimension values, attributes. , simplicity, just read everything.","code":"getDataTDB <- function(uri) { set_allocation_size_preference(1e7) # larger than local default value arr <- tiledb_array(uri, return_as=\"data.frame\") res <- arr[] res } uri <- \"/tmp/tiledb/beancounter\" res <- getDataFromSQL(con) storeData(dat, uri) chk <- getDataTDB(uri) print(dim(chk)) cat(\"Done!\\n\")"},{"path":"/articles/data-ingestion-from-sql.html","id":"see-also","dir":"Articles","previous_headings":"","what":"See Also","title":"Date Ingestion from SQL: A Commented Example","text":"vignette TileDB MariaDB Examples shows use MariaDB via MyTile integration TileDB direct backend. TileDB R Tutorial useR! 2021 contained worked example writing much larger data set chunks. process similar simple example showed – addition requires suffient domain range dimension along (sequential parallel) loop reading chunks writing TileDB.","code":""},{"path":"/articles/data-ingestion-from-sql.html","id":"summary","dir":"Articles","previous_headings":"","what":"Summary","title":"Date Ingestion from SQL: A Commented Example","text":"vignette provides commented walk-worked example SQL--TileDB data ingestion.","code":""},{"path":"/articles/documentation.html","id":"prelimaries","dir":"Articles","previous_headings":"","what":"Prelimaries","title":"TileDB API Documentation","text":"show two initial basic examples dense sparse array simply create array data disk refer later examples follow.","code":"library(tiledb) tdir <- tempdir() uridense <- file.path(tdir, \"dense\") uridensefix <- file.path(tdir, \"densefix\") uridensevar <- file.path(tdir, \"densevar\") uridensewkey <- file.path(tdir, \"denseenc\") create_array <- function(array_name) { # Check if the array already exists. if (tiledb_object_type(array_name) == \"ARRAY\") { message(\"Array already exists.\") return(invisible(NULL)) } # The array will be 4x4 with dimensions \"rows\" and \"cols\", with domain [1,4]. dom <- tiledb_domain(dims = c(tiledb_dim(\"rows\", c(1L, 4L), 4L, \"INT32\"), tiledb_dim(\"cols\", c(1L, 4L), 4L, \"INT32\"))) # The array will be dense with a single attribute \"a\" so each (i,j) cell can store an integer. schema <- tiledb_array_schema(dom, attrs = tiledb_attr(\"a\", type = \"INT32\")) # Create the (empty) array on disk, and return the path invisibly invisible(tiledb_array_create(array_name, schema)) } write_array <- function(array_name) { data <- array(c(c(1L, 5L, 9L, 13L), c(2L, 6L, 10L, 14L), c(3L, 7L, 11L, 15L), c(4L, 8L, 12L, 16L)), dim = c(4,4)) # Open the array and write to it. A <- tiledb_array(uri = array_name) A[] <- data } create_array(uridense) write_array(uridense) urisparse <- file.path(tdir, \"sparse\") create_array <- function(array_name) { # Check if the array already exists. if (tiledb_object_type(array_name) == \"ARRAY\") { message(\"Array already exists.\") return(invisible(NULL)) } # The array will be 4x4 with dimensions \"rows\" and \"cols\", with domain [1,4]. dom <- tiledb_domain(dims = c(tiledb_dim(\"rows\", c(1L, 4L), 4L, \"INT32\"), tiledb_dim(\"cols\", c(1L, 4L), 4L, \"INT32\"))) # The array will be dense with a single attribute \"a\" so each (i,j) cell can store an integer. schema = tiledb_array_schema(dom, attrs=tiledb_attr(\"a\", type = \"INT32\"), sparse = TRUE) # Create the (empty) array on disk, and return the path invisibly. invisible(tiledb_array_create(array_name, schema)) } write_array <- function(array_name) { I <- c(1, 2, 2) J <- c(1, 4, 3) data <- c(1L, 2L, 3L) # Open the array and write to it. A <- tiledb_array(uri = array_name) A[I, J] <- data } create_array(urisparse) write_array(urisparse) close_and_reopen <- function(arr, txt) { res <- tiledb:::libtiledb_array_close(arr@ptr) res <- tiledb:::libtiledb_array_open_with_ptr(arr@ptr, txt) }"},{"path":[]},{"path":[]},{"path":"/articles/documentation.html","id":"creating-dimensions","dir":"Articles","previous_headings":"API Usage > Creating Arrays","what":"Creating Dimensions","title":"TileDB API Documentation","text":"","code":"library(tiledb) # Create dimension dim <- tiledb_dim(\"dim1\", c(1L, 4L), 2L, \"INT32\") # String dimenions: no values for domain and extent strdim <- tiledb_dim(\"dim2\", NULL, NULL, \"ASCII\")"},{"path":"/articles/documentation.html","id":"creating-the-array-domain","dir":"Articles","previous_headings":"API Usage > Creating Arrays","what":"Creating the Array Domain","title":"TileDB API Documentation","text":"","code":"library(tiledb) # .. create dimensions `dim1`, `dim2` dim1 <- tiledb_dim(\"dim1\", c(1L, 4L), 2L, \"INT32\") dim2 <- tiledb_dim(\"dim2\", c(1L, 2L), 2L, \"INT32\") # Create domain with two dimensions # In C++: domain.add_dimensions(dim1).add_dimension(dim2) dom <- tiledb_domain(dims = c(dim1, dim2))"},{"path":"/articles/documentation.html","id":"creating-attributes","dir":"Articles","previous_headings":"API Usage > Creating Arrays","what":"Creating Attributes","title":"TileDB API Documentation","text":"","code":"# Create attribute attr <- tiledb_attr(\"attr\", type = \"INT32\") # Create attribute attr <- tiledb_attr(\"a1\", type = \"INT32\") # Access cell value via generic or functions cell_val_num(attr) tiledb_attribute_get_cell_val_num(attr) ## Attribute value counts can be set via a generic method and a direct method cell_val_num(attr) <- 3 tiledb_attribute_set_cell_val_num(attr, 3) ## set char attribute to variable length which is encoded as a NA cell_val_num(attr) <- NA tiledb_attribute_set_cell_val_num(attr, NA)"},{"path":"/articles/documentation.html","id":"setting-fill-values","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Creating Attributes","what":"Setting Fill Values","title":"TileDB API Documentation","text":"","code":"# ... create int attribute attr attr <- tiledb_attr(\"a1\", type = \"INT32\") # set fill value to 42L tiledb_attribute_set_fill_value(attr, 42L) # ... create variable-sized attributte attr attr <- tiledb_attr(\"attr\", type = \"CHAR\") tiledb_attribute_set_cell_val_num(attr, 3) # set fill value to \"...\" tiledb_attribute_set_fill_value(attr, \"...\")"},{"path":"/articles/documentation.html","id":"setting-a-compressor","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Creating Attributes","what":"Setting a Compressor","title":"TileDB API Documentation","text":"","code":"comp <- tiledb_filter(\"GZIP\") tiledb_filter_set_option(comp,\"COMPRESSION_LEVEL\", 10) # Create a filter list with the compressor filter_list <- tiledb_filter_list(comp) # Create attribute with the filter list attr <- tiledb_attr(\"attr\", \"INT32\", filter_list = filter_list)"},{"path":"/articles/documentation.html","id":"setting-other-filters","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Creating Attributes","what":"Setting Other Filters","title":"TileDB API Documentation","text":"","code":"# Create filters f1 <- tiledb_filter(\"BIT_WIDTH_REDUCTION\") f2 <- tiledb_filter(\"ZSTD\") # Create a filter list with the two filters filter_list <- tiledb_filter_list(c(f1,f2)) # Create attribute with the filter list attr <- tiledb_attr(\"attr\", \"INT32\", filter_list = filter_list)"},{"path":"/articles/documentation.html","id":"creating-the-array-schema","dir":"Articles","previous_headings":"API Usage > Creating Arrays","what":"Creating the Array Schema","title":"TileDB API Documentation","text":"","code":"# ... create domain dom attr1 <- tiledb_attr(\"attr1\", \"INT32\", filter_list = filter_list) attr2 <- tiledb_attr(\"attr2\", \"FLOAT64\", filter_list = filter_list) # Create a dense array schema <- tiledb_array_schema(dom, c(attr1, attr2), sparse = FALSE) # Or, create a sparse array # schema <- tiledb_array_schema(dom, c(attr1, attr2), sparse = TRUE)"},{"path":"/articles/documentation.html","id":"setting-the-tile-and-cell-order","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Creating the Array Schema","what":"Setting the Tile and Cell Order","title":"TileDB API Documentation","text":"","code":"# ... create domain dom # ... create attributes attr1, attr2 # The tile and order can be \"COL_MAJOR\" or \"ROW_MAJOR\" schema <- tiledb_array_schema(dom, c(attr1, attr2), cell_order = \"COL_MAJOR\", tile_order = \"COL_MAJOR\")"},{"path":"/articles/documentation.html","id":"setting-the-data-tile-capacity","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Creating the Array Schema","what":"Setting the Data Tile Capacity","title":"TileDB API Documentation","text":"","code":"# set capacity capacity(schema) <- 100000 tiledb_array_schema_set_capacity(schema, 10000) # get capacity capacity(schema) tiledb_array_schema_get_capacity(schema)"},{"path":"/articles/documentation.html","id":"allowing-duplicates","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Creating the Array Schema","what":"Allowing Duplicates","title":"TileDB API Documentation","text":"","code":"sch <- schema(urisparse) # get 'duplicates allowed?' status allows_dups(sch) tiledb_array_schema_get_allows_dups(sch) # set 'duplicates allowed?' status allows_dups(sch) <- TRUE tiledb_array_schema_set_allows_dups(sch, TRUE)"},{"path":"/articles/documentation.html","id":"checking-correctness","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Creating the Array Schema","what":"Checking Correctness","title":"TileDB API Documentation","text":"","code":"check(sch) tiledb_array_schema_check(sch)"},{"path":[]},{"path":"/articles/documentation.html","id":"creating-a-filter-list","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Setting Filters","what":"Creating a Filter List","title":"TileDB API Documentation","text":"","code":"# create a \"GZIP\" compression filter flt <- tiledb_filter(\"GZIP\") # set the option 'COMPRESSION_LEVEL' to 10 tiledb_filter_set_option(flt, \"COMPRESSION_LEVEL\", 10) # create a filter list with this filter fltlst <- tiledb_filter_list(flt)"},{"path":"/articles/documentation.html","id":"other-filters","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Setting Filters","what":"Other Filters","title":"TileDB API Documentation","text":"","code":"# create a filter list object with both fltlst <- tiledb_filter_list(c(flt1, flt2))"},{"path":"/articles/documentation.html","id":"setting-the-tile-chunk-size","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Setting Filters","what":"Setting the Tile Chunk Size","title":"TileDB API Documentation","text":"","code":"# ... create filter list set_max_chunk_size(filter_list, 10000) tiledb_filter_list_set_max_chunk_size(filter_list, 10000) max_chunk_size(filter_list) tiledb_filter_list_get_max_chunk_size(filter_list)"},{"path":"/articles/documentation.html","id":"setting-a-filter-list-for-an-attribute","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Setting Filters","what":"Setting a Filter List for an Attribute","title":"TileDB API Documentation","text":"","code":"# create (or access) an attribute attr <- tiledb_attr(\"a\", \"INT32\") # create a filter list flt1 <- tiledb_filter(\"BIT_WIDTH_REDUCTION\") flt2 <- tiledb_filter(\"ZSTD\") fltlst <- tiledb_filter_list(c(flt1, flt2)) # set the filter list filter_list(attr) <- fltlst"},{"path":"/articles/documentation.html","id":"setting-a-filter-list-for-a-dimension","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Setting Filters","what":"Setting a Filter List for a Dimension","title":"TileDB API Documentation","text":"","code":"d <- tiledb_dim(\"d\", c(1L, 10L), 1L, \"INT32\") # create a filter list flt1 <- tiledb_filter(\"BIT_WIDTH_REDUCTION\") flt2 <- tiledb_filter(\"ZSTD\") fltlst <- tiledb_filter_list(c(flt1, flt2)) # assign the filter list filter_list(d) <- fltlst"},{"path":"/articles/documentation.html","id":"setting-a-filter-list-for-all-dimensions","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Setting Filters","what":"Setting a Filter List for All Dimensions","title":"TileDB API Documentation","text":"","code":"# ... create (or retrieve) array schema sch # ... create filter list fl # assign filter list to schema tiledb_array_schema_set_coords_filter_list(sch, fl) # Alternatively create the schema and set the coordinates filter list sch <- tiledb_array_schema(dom, c(attr1, attr2), coords_filter_list = fl)"},{"path":"/articles/documentation.html","id":"setting-a-filter-list-for-variable-sized-value-offsets","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Setting Filters","what":"Setting a Filter List for Variable-Sized Value Offsets","title":"TileDB API Documentation","text":"","code":"# ... create (or retrieve) array schema sch # ... create filter list fl # assign filter list to schema tiledb_array_schema_set_offsets_filter_list(sch, fl) # Create the schema setting the offsets filter list sch <- tiledb_array_schema(dom, c(attr1, attr2), offsets_filter_list = fl)"},{"path":"/articles/documentation.html","id":"setting-coordinate-and-offset-filters","dir":"Articles","previous_headings":"API Usage > Creating Arrays > Setting Filters","what":"Setting Coordinate and Offset Filters","title":"TileDB API Documentation","text":"","code":"# ... create domain dom # ... create attributes attr1, attr2 # ... create filter lists fl1, fl2, similar to attributes f1 <- tiledb_filter(\"BIT_WIDTH_REDUCTION\") f2 <- tiledb_filter(\"ZSTD\") fl1 <- tiledb_filter_list(c(f1)) fl2 <- tiledb_filter_list(c(f2)) # Create the schema setting the coordinates and offsets filter lists schema <- tiledb_array_schema(dom, c(attr1, attr2), coords_filter_list = fl1, offsets_filter_list = fl2)"},{"path":"/articles/documentation.html","id":"creating-the-array","dir":"Articles","previous_headings":"API Usage > Creating Arrays","what":"Creating the Array","title":"TileDB API Documentation","text":"","code":"# ... create array schema # Create the array tiledb_array_create(uridense, schema)"},{"path":"/articles/documentation.html","id":"creating-encrypted-arrays","dir":"Articles","previous_headings":"API Usage > Creating Arrays","what":"Creating Encrypted Arrays","title":"TileDB API Documentation","text":"","code":"# assume previously created schema 'sch' # use encryption key encryption_key <- \"0123456789abcdeF0123456789abcdeF\" # create encrypted array at 'uri' with schema 'sch' tiledb_array_create(uridensewkey, sch, encryption_key)"},{"path":[]},{"path":"/articles/documentation.html","id":"writing-in-dense-subarrays","dir":"Articles","previous_headings":"API Usage > Writing Arrays","what":"Writing in Dense Subarrays","title":"TileDB API Documentation","text":"","code":"## prepare a larger 5 x 5 to embed into tmp <- tempfile() d1 <- tiledb_dim(\"d1\", domain = c(1L, 5L)) d2 <- tiledb_dim(\"d2\", domain = c(1L, 5L)) dom <- tiledb_domain(c(d1, d2)) val <- tiledb_attr(name=\"val\", type = \"INT32\") sch <- tiledb_array_schema(dom, c(val)) tiledb_array_create(tmp, sch) dat <- matrix(as.integer(rnorm(25)*100), 5, 5) arr <- tiledb_array(tmp, return_as = \"data.frame\") arr[] <- dat # Prepare a 2x3 dense array # Contrary to Python, R by default stores arrays in col-major order data <- array(c(1L, 4L, 2L, 5L, 3L, 6L), dim=c(2,3)) # Prepare the [1,2] x [2,4] subarray to write to I <- c(1:2) J <- c(2:4) # Open the array and write the data to it A <- tiledb_dense(uri = tmp) A[I, J] <- data unlink(tmp, recursive=TRUE)"},{"path":"/articles/documentation.html","id":"basic-writing-using-low-level-code","dir":"Articles","previous_headings":"API Usage > Writing Arrays > Writing in Dense Subarrays","what":"Basic Writing using Low-Level Code","title":"TileDB API Documentation","text":"","code":"ctx <- tiledb_ctx() arrptr <- tiledb:::libtiledb_array_open(ctx@ptr, uridense, \"WRITE\") ## data: simple (integer sequence) of 1:16 times 10 vec <- 1:16 * 10L subarr <- c(1L,4L, 1L,4L) qryptr <- tiledb:::libtiledb_query(ctx@ptr, arrptr, \"WRITE\") qryptr <- tiledb:::libtiledb_query_set_subarray(qryptr, subarr) qryptr <- tiledb:::libtiledb_query_set_layout(qryptr, \"COL_MAJOR\") qryptr <- tiledb:::libtiledb_query_set_buffer(qryptr, \"a\", vec) qryptr <- tiledb:::libtiledb_query_submit(qryptr) res <- tiledb:::libtiledb_array_close(arrptr)"},{"path":"/articles/documentation.html","id":"writing-sparse-cells","dir":"Articles","previous_headings":"API Usage > Writing Arrays","what":"Writing Sparse Cells","title":"TileDB API Documentation","text":"","code":"tmp <- urisparse unlink(tmp, recursive=TRUE) d1 <- tiledb_dim(\"d1\", domain = c(1L, 5L)) d2 <- tiledb_dim(\"d2\", domain = c(1L, 5L)) dom <- tiledb_domain(c(d1, d2)) val <- tiledb_attr(\"val\", type = \"INT32\") sch <- tiledb_array_schema(dom, val, sparse=TRUE) tiledb_array_create(tmp, sch) # Prepare some data data <- c(3L, 4L, 1L, 2L) I <- c(3, 4, 1, 2) J <- c(3, 4, 2, 1) # Open the array and write the data to it A <- tiledb_array(uri = tmp) A[I, J] <- data"},{"path":"/articles/documentation.html","id":"writing-encrypted-arrays","dir":"Articles","previous_headings":"API Usage > Writing Arrays","what":"Writing Encrypted Arrays","title":"TileDB API Documentation","text":"","code":"# open for writing with corresponding encryption key A <- tiledb_array(uridensewkey, encryption_key = encryption_key) # access array as usual"},{"path":"/articles/documentation.html","id":"fixed-length-attributes","dir":"Articles","previous_headings":"API Usage > Writing Arrays","what":"Fixed-length Attributes","title":"TileDB API Documentation","text":"","code":"if (dir.exists(uridensefix)) unlink(uridensefix, recursive=TRUE) d1 <- tiledb_dim(\"d1\", domain = c(1L, 4L)) d2 <- tiledb_dim(\"d2\", domain = c(1L, 4L)) dom <- tiledb_domain(c(d1, d2)) vec <- 1:32 * 10L attr <- tiledb_attr(\"a\", type = r_to_tiledb_type(vec)) ## set to two values per cell tiledb:::libtiledb_attribute_set_cell_val_num(attr@ptr, 2) sch <- tiledb_array_schema(dom, attr) tiledb_array_create(uridensefix, sch) ctx <- tiledb_ctx() arrptr <- tiledb:::libtiledb_array_open(ctx@ptr, uridensefix, \"WRITE\") subarr <- c(1L,4L, 1L,4L) qryptr <- tiledb:::libtiledb_query(ctx@ptr, arrptr, \"WRITE\") qryptr <- tiledb:::libtiledb_query_set_subarray(qryptr, subarr) qryptr <- tiledb:::libtiledb_query_set_layout(qryptr, \"COL_MAJOR\") qryptr <- tiledb:::libtiledb_query_set_buffer(qryptr, \"a\", vec) qryptr <- tiledb:::libtiledb_query_submit(qryptr) res <- tiledb:::libtiledb_array_close(arrptr) #TODO Higher-level R support"},{"path":"/articles/documentation.html","id":"var-length-attributes","dir":"Articles","previous_headings":"API Usage > Writing Arrays","what":"Var-length Attributes","title":"TileDB API Documentation","text":"","code":"if (dir.exists(uridensevar)) unlink(uridensevar, recursive=TRUE) ## Define array ## The array will be 4x4 with dimensions \"rows\" and \"cols\", with domain [1,4]. dom <- tiledb_domain(dims = c(tiledb_dim(\"rows\", c(1L, 4L), 4L, \"INT32\"), tiledb_dim(\"cols\", c(1L, 4L), 4L, \"INT32\"))) attr <- tiledb_attr(\"a1\", type = \"CHAR\") ## set to variable length tiledb:::libtiledb_attribute_set_cell_val_num(attr@ptr, NA) ## now set the schema ctx <- tiledb_ctx() schptr <- tiledb:::libtiledb_array_schema_create(ctx@ptr, \"DENSE\") tiledb:::libtiledb_array_schema_set_domain(schptr, dom@ptr) tiledb:::libtiledb_array_schema_set_cell_order(schptr, \"COL_MAJOR\") tiledb:::libtiledb_array_schema_set_tile_order(schptr, \"COL_MAJOR\") tiledb:::libtiledb_array_schema_add_attribute(schptr, attr@ptr) ## Create the (empty) array on disk. tiledb:::libtiledb_array_create(uridensevar, schptr) data <- \"abbcccddeeefghhhijjjkklmnoop\"; offsets <- c(0L, 1L, 3L, 6L, 8L, 11L, 12L, 13L, 16L, 17L, 20L, 22L, 23L, 24L, 25L, 27L) ctx <- tiledb_ctx() arrptr <- tiledb:::libtiledb_array_open(ctx@ptr, uridensevar, \"WRITE\") qryptr <- tiledb:::libtiledb_query(ctx@ptr, arrptr, \"WRITE\") qryptr <- tiledb:::libtiledb_query_set_layout(qryptr, \"COL_MAJOR\") bufptr <- tiledb:::libtiledb_query_buffer_var_char_create(offsets, data) qryptr <- tiledb:::libtiledb_query_set_buffer_var_char(qryptr, \"a1\", bufptr) qryptr <- tiledb:::libtiledb_query_submit(qryptr) tiledb:::libtiledb_array_close(arrptr) #TODO Higher-level R support"},{"path":"/articles/documentation.html","id":"writing-at-a-timestamp","dir":"Articles","previous_headings":"API Usage > Writing Arrays","what":"Writing at a Timestamp","title":"TileDB API Documentation","text":"","code":"# 'at' uses Sys.time() from R in seconds, and shifts back 10 minutes at <- Sys.time() - 10*60 # 'arr' is an already created array, could also be encrypted and carry key arr <- tiledb_array_open_at(arr, \"WRITE\", Sys.time() - 600) # arr is now open for writing, any suitable content can be written the usual way"},{"path":"/articles/documentation.html","id":"getting-the-fragment-info","dir":"Articles","previous_headings":"API Usage > Writing Arrays","what":"Getting the Fragment Info","title":"TileDB API Documentation","text":"","code":"# continuing from previous example on dense variable length array # (but this works of course with any array after a write is needed # Number of fragments numfrag <- tiledb_query_get_fragment_num(qry) # URI of given fragment, with 0 <= idx < numfrag uri <- tiledb_query_get_fragment_uri(qry, idx) # Timestamp range of given fragment, with 0 <= idx < numfrag tsrange <- tiledb_query_get_fragment_timestamp_range(qry, idx)"},{"path":[]},{"path":[]},{"path":"/articles/documentation.html","id":"inspecting-the-array-schema","dir":"Articles","previous_headings":"API Usage > Reading Arrays > Reading the Array Schema","what":"Inspecting the array schema","title":"TileDB API Documentation","text":"","code":"# get a schema directly from storage, uri holds a valid array URI uri <- \"