Adding more coverage (#106)

* Updated metadata functions and tests

* Generalize consolidation adding optional config object

* Add some VFS documentation

* Make domain creator work on directly supplied dimension object

* Correct one-char typo

* Convert single args to list if need be

* Update notebook documentation

.Rbuildignore

@@ -11,3 +11,4 @@
 ^inst/examples/quickstart_sparse$
 ^inst/examples/array_metadata_array$
 ^\.editorconfig$
+^src/unused_*cpp.txt$

NAMESPACE

@@ -70,7 +70,6 @@ export(tiledb_stats_enable)
 export(tiledb_stats_print)
 export(tiledb_subarray)
 export(tiledb_version)
-exportClasses("tiledb_sparse")
 exportClasses(tiledb_array_schema)
 exportClasses(tiledb_attr)
 exportClasses(tiledb_config)
@@ -80,6 +79,7 @@ exportClasses(tiledb_dim)
 exportClasses(tiledb_domain)
 exportClasses(tiledb_filter)
 exportClasses(tiledb_filter_list)
+exportClasses(tiledb_sparse)
 exportMethods("[")
 exportMethods(attrs)
 exportMethods(cell_order)

R/ArraySchema.R

@@ -6,7 +6,7 @@ setClass("tiledb_array_schema",
          slots = list(ptr = "externalptr"))
 
 tiledb_array_schema.from_ptr <- function(ptr) {
-   if (missing(ptr) || typeof(ptr) != "externalptr" || is.null(ptr)) {
+  if (missing(ptr) || typeof(ptr) != "externalptr" || is.null(ptr)) {
     stop("ptr argument must be a non NULL externalptr to a tiledb_array_schema instance")
   }
   new("tiledb_array_schema", ptr = ptr)
@@ -51,6 +51,9 @@ tiledb_array_schema <- function(
     stop("domain argument must be a tiledb::Domain")
   }
   is_attr <- function(obj) is(obj, "tiledb_attr")
+  if (is_attr(attrs)) {                 # if an attrs object given:
+    attrs <- list(attrs)                # make it a list so that lapply works below
+  }
   if (missing(attrs) || length(attrs) == 0 || !all(vapply(attrs, is_attr, logical(1)))) {
     stop("attrs argument must be a list of one or tiled_attr objects")
   }

R/Domain.R

@@ -30,6 +30,9 @@ tiledb_domain <- function(dims, ctx = tiledb_get_context()) {
     stop("argument ctx must be a tiledb_ctx")
   }
   is_dim <- function(obj) is(obj, "tiledb_dim")
+  if (is_dim(dims)) {                   # if a dim object given:
+    dims <- list(dims)                  # make it a vector so that lapply works below
+  }
   if (missing(dims) || length(dims) == 0 || !all(vapply(dims, is_dim, logical(1)))) {
     stop("argument dims must be a list of one or more tileb_dim")
   }

R/FilterList.R

@@ -28,6 +28,9 @@ tiledb_filter_list <- function(filters = c(), ctx = tiledb_get_context()) {
     stop("argument ctx must be a tiledb_ctx")
   }
   is_filter <- function(obj) is(obj, "tiledb_filter")
+  if (is_filter(filters)) {             # if a filters object given:
+    filters <- list(filters)            # make it a list so that lapply works below
+  }
   filter_ptrs = c()
   if (length(filters) > 0) {
     if (!all(vapply(filters, is_filter, logical(1)))) {

R/Metadata.R

@@ -4,17 +4,14 @@
 
 ##' Test if TileDB Array has Metadata
 ##'
-##' @param arr A TileDB Array object, or a character URI describing one
+##' @param arr A TileDB Array object
 ##' @param key A character value describing a metadata key
 ##' @return A logical value indicating if the given key exists in the
 ##'   metdata of the given array
 ##' @export
 tiledb_has_metadata <- function(arr, key) {
-  if (is.character(arr)) {
-    return(has_metadata_simple(arr, key))
-  } else if (!.isArray(arr)) {
-    message("Neither (text) URI nor Array.")
-    return(NULL)
+  if (!is(arr, "tiledb_sparse") && !is(arr, "tiledb_dense")) {
+    stop("Argument must be a TileDB (dense or sparse) array.", call.=FALSE)
   }
 
   ## Now deal with (default) case of an array object
@@ -23,8 +20,8 @@ tiledb_has_metadata <- function(arr, key) {
     stop("Array is not open for reading, cannot access metadata.", call.=FALSE)
   }
 
-  ## Run query
-  return(has_metadata_ptr(arr@ptr, key))
+  res <- libtiledb_array_get_metadata_list(arr@ptr)
+  return(key %in% names(res))
 }
 
 ##' Return count of TileDB Array Metadata objects
@@ -33,11 +30,8 @@ tiledb_has_metadata <- function(arr, key) {
 ##' @return A integer variable with the number of Metadata objects
 ##' @export
 tiledb_num_metadata <- function(arr) {
-  if (is.character(arr)) {
-    return(num_metadata_simple(arr))
-  } else if (!.isArray(arr)) {
-    message("Neither (text) URI nor Array.")
-    return(NULL)
+  if (!is(arr, "tiledb_sparse") && !is(arr, "tiledb_dense")) {
+    stop("Argument must be a TileDB (dense or sparse) array.", call.=FALSE)
   }
 
   ## Now deal with (default) case of an array object
@@ -47,21 +41,19 @@ tiledb_num_metadata <- function(arr) {
   }
 
   ## Run query
-  return(num_metadata_ptr(arr@ptr))
+  return(libtiledb_array_get_metadata_num(arr@ptr))
 }
 
 ##' Return a TileDB Array Metadata object given by key
 ##'
 ##' @param arr A TileDB Array object, or a character URI describing one
 ##' @param key A character value describing a metadata key
-##' @return A object stored in the Metadata under the given key
+##' @return A object stored in the Metadata under the given key,
+##' or \sQuote{NULL} if none found.
 ##' @export
 tiledb_get_metadata <- function(arr, key) {
-  if (is.character(arr)) {
-    return(get_metadata_simple(arr, key))
-  } else if (!.isArray(arr)) {
-    message("Neither (text) URI nor Array.")
-    return(NULL)
+  if (!is(arr, "tiledb_sparse") && !is(arr, "tiledb_dense")) {
+    stop("Argument must be a TileDB (dense or sparse) array.", call.=FALSE)
   }
 
   ## Now deal with (default) case of an array object
@@ -70,8 +62,11 @@ tiledb_get_metadata <- function(arr, key) {
     stop("Array is not open for reading, cannot access metadata.", call.=FALSE)
   }
 
-  ## Run query
-  return(get_metadata_ptr(arr@ptr, key))
+  res <- libtiledb_array_get_metadata_list(arr@ptr)
+  if (key %in% names(res))
+    return(res[[key]])
+  else
+    return(NULL)
 }
 
 ##' Store an object in TileDB Array Metadata under given key
@@ -82,11 +77,8 @@ tiledb_get_metadata <- function(arr, key) {
 ##' @return A boolean value indicating success
 ##' @export
 tiledb_put_metadata <- function(arr, key, val) {
-  if (is.character(arr)) {
-    return(put_metadata_simple(arr, key, val))
-  } else if (!.isArray(arr)) {
-    message("Neither (text) URI nor Array.")
-    return(NULL)
+  if (!is(arr, "tiledb_sparse") && !is(arr, "tiledb_dense")) {
+    stop("Argument must be a TileDB (dense or sparse) array.", call.=FALSE)
   }
 
   ## Now deal with (default) case of an array object
@@ -96,7 +88,7 @@ tiledb_put_metadata <- function(arr, key, val) {
   }
 
   ## Run query
-  return(put_metadata_ptr(arr@ptr, key, val))
+  return(libtiledb_array_put_metadata(arr@ptr, key, val))
 }
 
 
@@ -106,13 +98,8 @@ tiledb_put_metadata <- function(arr, key, val) {
 ##' @return A object stored in the Metadata under the given key
 ##' @export
 tiledb_get_all_metadata <- function(arr) {
-  if (is.character(arr)) {
-    res <- get_all_metadata_simple(arr)
-    class(res) <- "tiledb_metadata"
-    return(res)
-  } else if (!.isArray(arr)) {
-    message("Neither (text) URI nor Array.")
-    return(NULL)
+  if (!is(arr, "tiledb_sparse") && !is(arr, "tiledb_dense")) {
+    stop("Argument must be a TileDB (dense or sparse) array.", call.=FALSE)
   }
 
   ## Now deal with (default) case of an array object
@@ -122,7 +109,7 @@ tiledb_get_all_metadata <- function(arr) {
   }
 
   ## Run query
-  res <- get_all_metadata_ptr(arr@ptr)
+  res <- libtiledb_array_get_metadata_list(arr@ptr)
   class(res) <- "tiledb_metadata"
   return(res)
 }
@@ -138,16 +125,13 @@ print.tiledb_metadata <- function(x, width=NULL, ...) {
 
 ##' Delete a TileDB Array Metadata object given by key
 ##'
-##' @param arr A TileDB Array object, or a character URI describing one
+##' @param arr A TileDB Array object
 ##' @param key A character value describing a metadata key
 ##' @return A boolean indicating success
 ##' @export
 tiledb_delete_metadata <- function(arr, key) {
-  if (is.character(arr)) {
-    return(delete_metadata_simple(arr, key))
-  } else if (!.isArray(arr)) {
-    message("Neither (text) URI nor Array.")
-    return(NULL)
+  if (!is(arr, "tiledb_sparse") && !is(arr, "tiledb_dense")) {
+    stop("ctx argument must be a TileDB (dense or sparse) array.", call.=FALSE)
   }
 
   ## Now deal with (default) case of an array object
@@ -156,6 +140,7 @@ tiledb_delete_metadata <- function(arr, key) {
     stop("Array is not open for writing, cannot access metadata.", call.=FALSE)
   }
 
-  ## Run query
-  return(delete_metadata_ptr(arr@ptr, key))
+  ## Run metadata removal
+  libtiledb_array_delete_metadata(arr@ptr, key);
+  invisible(TRUE)
 }

R/RcppExports.R

@@ -1,62 +1,6 @@
 # Generated by using Rcpp::compileAttributes() -> do not edit by hand
 # Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
 
-has_metadata_simple <- function(array_name, key) {
-    .Call(`_tiledb_has_metadata_simple`, array_name, key)
-}
-
-has_metadata_ptr <- function(array, key) {
-    .Call(`_tiledb_has_metadata_ptr`, array, key)
-}
-
-num_metadata_simple <- function(array_name) {
-    .Call(`_tiledb_num_metadata_simple`, array_name)
-}
-
-num_metadata_ptr <- function(array) {
-    .Call(`_tiledb_num_metadata_ptr`, array)
-}
-
-get_metadata_simple <- function(array_name, key) {
-    .Call(`_tiledb_get_metadata_simple`, array_name, key)
-}
-
-get_metadata_ptr <- function(array, key) {
-    .Call(`_tiledb_get_metadata_ptr`, array, key)
-}
-
-put_metadata_simple <- function(array_name, key, obj) {
-    .Call(`_tiledb_put_metadata_simple`, array_name, key, obj)
-}
-
-put_metadata_ptr <- function(array, key, obj) {
-    .Call(`_tiledb_put_metadata_ptr`, array, key, obj)
-}
-
-get_metadata_from_index_ptr <- function(array, idx) {
-    .Call(`_tiledb_get_metadata_from_index_ptr`, array, idx)
-}
-
-get_metadata_from_index_simple <- function(array_name, idx) {
-    .Call(`_tiledb_get_metadata_from_index_simple`, array_name, idx)
-}
-
-get_all_metadata_simple <- function(array_name) {
-    .Call(`_tiledb_get_all_metadata_simple`, array_name)
-}
-
-get_all_metadata_ptr <- function(array) {
-    .Call(`_tiledb_get_all_metadata_ptr`, array)
-}
-
-delete_metadata_simple <- function(array_name, key) {
-    .Call(`_tiledb_delete_metadata_simple`, array_name, key)
-}
-
-delete_metadata_ptr <- function(array, key) {
-    .Call(`_tiledb_delete_metadata_ptr`, array, key)
-}
-
 tiledb_datatype_R_type <- function(datatype) {
     .Call(`_tiledb_tiledb_datatype_R_type`, datatype)
 }
@@ -389,8 +333,28 @@ libtiledb_array_nonempty_domain <- function(array) {
     .Call(`_tiledb_libtiledb_array_nonempty_domain`, array)
 }
 
-libtiledb_array_consolidate <- function(ctx, uri) {
-    .Call(`_tiledb_libtiledb_array_consolidate`, ctx, uri)
+libtiledb_array_consolidate <- function(ctx, uri, cfgptr = NULL) {
+    invisible(.Call(`_tiledb_libtiledb_array_consolidate`, ctx, uri, cfgptr))
+}
+
+libtiledb_array_put_metadata <- function(array, key, obj) {
+    .Call(`_tiledb_libtiledb_array_put_metadata`, array, key, obj)
+}
+
+libtiledb_array_get_metadata_num <- function(array) {
+    .Call(`_tiledb_libtiledb_array_get_metadata_num`, array)
+}
+
+libtiledb_array_get_metadata_from_index <- function(array, idx) {
+    .Call(`_tiledb_libtiledb_array_get_metadata_from_index`, array, idx)
+}
+
+libtiledb_array_get_metadata_list <- function(array) {
+    .Call(`_tiledb_libtiledb_array_get_metadata_list`, array)
+}
+
+libtiledb_array_delete_metadata <- function(array, key) {
+    invisible(.Call(`_tiledb_libtiledb_array_delete_metadata`, array, key))
 }
 
 libtiledb_query <- function(ctx, array, type) {

R/SparseArray.R

@@ -4,7 +4,7 @@
 #' @slot uri A character despription
 #' @slot as.data.frame A logical value
 #' @slot ptr External pointer to the underlying implementation
-#' @exportClass "tiledb_sparse"
+#' @exportClass tiledb_sparse
 setClass("tiledb_sparse",
          slots = list(ctx = "tiledb_ctx", uri = "character",
                       as.data.frame = "logical", ptr = "externalptr"))

TileDB-R.Rproj

@@ -14,4 +14,4 @@ LaTeX: pdfLaTeX
 
 BuildType: Package
 PackageInstallArgs: --no-multiarch --with-keep.source
-PackageRoxygenize: rd,collate,namespace
+PackageRoxygenize: rd,namespace