Update the minimally supported TileDB Embedded version to release 2.7.0

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: tiledb
 Type: Package
-Version: 0.20.1.3
+Version: 0.20.1.4
 Title: Universal Storage Engine for Sparse and Dense Multidimensional Arrays
 Authors@R: c(person("TileDB, Inc.", role = c("aut", "cph")),
  person("Dirk", "Eddelbuettel", email = "dirk@tiledb.com", role = "cre"))

NEWS.md

@@ -12,6 +12,10 @@
 
 * The tile extend getter function is now able to access a wider range of possible values (#577)
 
+## Build and Test Systems
+
+* The minimal version of TileDB Embedded that can be used with the R package is now release 2.7.0 (#578)
+
 
 # tilebd 0.20.1
 

R/ArraySchema.R

@@ -84,7 +84,7 @@ tiledb_array_schema <- function(domain,
               "tile_order argument must be a scalar string" = is.scalar(tile_order, "character"),
               "coords_filter_list must be a filter list"    = is.null(coords_filter_list) || is(coords_filter_list, "tiledb_filter_list"),
               "offsets_filter_list must be a filter_list"   = is.null(offsets_filter_list) || is(offsets_filter_list, "tiledb_filter_list"),
-              "validity_filter_list must be a_filter_list"  = is.null(validity_filter_list) || is(validity_filter_list, "tiledb_filter_list") || (tiledb_version(TRUE) < "2.6.0"),
+              "validity_filter_list must be a_filter_list"  = is.null(validity_filter_list) || is(validity_filter_list, "tiledb_filter_list"),
               "'sparse' must be TRUE or FALSE"              = is.logical(sparse),
               "'allows_dups' must be TRUE or FALSE"         = is.logical(allows_dups),
               "'allows_dups' requires 'sparse' TRUE"        = !allows_dups || sparse)
@@ -93,7 +93,7 @@ tiledb_array_schema <- function(domain,
     attr_ptr_list <- if (is.list(attrs)) lapply(attrs, function(obj) slot(obj, "ptr")) else list()
     coords_filter_list_ptr <- if (!is.null(coords_filter_list)) coords_filter_list@ptr else NULL
     offsets_filter_list_ptr <- if (!is.null(offsets_filter_list)) offsets_filter_list@ptr else NULL
-    validity_filter_list_ptr <- if (tiledb_version(TRUE) >= "2.6.0" && !is.null(validity_filter_list)) validity_filter_list@ptr else NULL
+    validity_filter_list_ptr <- if (!is.null(validity_filter_list)) validity_filter_list@ptr else NULL
 
     ptr <- libtiledb_array_schema(ctx@ptr, domain@ptr, attr_ptr_list, cell_order, tile_order,
                                   coords_filter_list_ptr, offsets_filter_list_ptr,
@@ -143,7 +143,7 @@ setMethod("show", signature(object = "tiledb_array_schema"),
     fl <- filter_list(object)
     nfc <- nfilters(fl$coords)
     nfo <- nfilters(fl$offsets)
-    nfv <- if (tiledb_version(TRUE) >= "2.6.0") nfilters(fl$validity) else 0
+    nfv <- nfilters(fl$validity)
     cat("tiledb_array_schema(\n    domain=", .as_text_domain(domain(object)), ",\n",
         "    attrs=c(\n        ", paste(sapply(attrs(object), .as_text_attribute), collapse=",\n        "), "\n    ),\n",
         "    cell_order=\"", cell_order(object), "\", ",
@@ -155,7 +155,7 @@ setMethod("show", signature(object = "tiledb_array_schema"),
         sep="")
     if (nfc > 0) cat("    coords_filter_list=", .as_text_filter_list(fl$coords), if (nfo + nfv > 0) "," else "", "\n", sep="")
     if (nfo > 0) cat("    offsets_filter_list=", .as_text_filter_list(fl$offsets), if (nfv > 0) ",\n" else "", sep="")
-    if (tiledb_version(TRUE) >= "2.6.0" && nfv > 0)
+    if (nfv > 0)
         cat("    validity_filter_list=", .as_text_filter_list(fl$validity), "\n", sep="")
     cat(")\n", sep="")
     #cat("tiledb_array_create(uri=tempfile(), schema=sch)) # or assign your URI here\n")
@@ -325,10 +325,10 @@ setGeneric("filter_list<-", function(x, value) standardGeneric("filter_list<-"))
 setMethod("filter_list", "tiledb_array_schema", function(object) {
   coords_ptr <- libtiledb_array_schema_get_coords_filter_list(object@ptr)
   offsets_ptr <- libtiledb_array_schema_get_offsets_filter_list(object@ptr)
-  validity_ptr <- if (tiledb_version(TRUE) >= "2.6.0") libtiledb_array_schema_get_validity_filter_list(object@ptr) else NULL
+  validity_ptr <- libtiledb_array_schema_get_validity_filter_list(object@ptr)
   return(c(coords = tiledb_filter_list.from_ptr(coords_ptr),
            offsets = tiledb_filter_list.from_ptr(offsets_ptr),
-           validity = if (tiledb_version(TRUE) >= "2.6.0") tiledb_filter_list.from_ptr(validity_ptr) else NULL))
+           validity = tiledb_filter_list.from_ptr(validity_ptr)))
 })
 
 # ' Set the Filter List for a TileDB Schema
@@ -377,8 +377,7 @@ tiledb_array_schema_set_offsets_filter_list <- function(sch, fl) {
 #' @export
 tiledb_array_schema_set_validity_filter_list <- function(sch, fl) {
   stopifnot(`The 'sch' argument must be a tiledb_array_schema object` = is(sch, "tiledb_array_schema"),
-            `The 'fl' argument must be a tiledb_filter_list object` = is(fl, "tiledb_filter_list"),
-            `This function requires TileDB 2.6.0 or later` = tiledb_version(TRUE) >= "2.6.0")
+            `The 'fl' argument must be a tiledb_filter_list object` = is(fl, "tiledb_filter_list"))
   sch@ptr <- libtiledb_array_schema_set_validity_filter_list(sch@ptr, fl@ptr)
   sch
 }
@@ -701,11 +700,9 @@ tiledb_schema_object <- function(array) {
     n_offsets <- nfilters(filterlist$offsets)
     offsets <- sapply(seq_len(n_offsets), function(i) tiledb_filter_type(filterlist$offsets[i-1]))
     offsetopts <- sapply(seq_len(n_offsets), function(i) .getFilterOption(filterlist$offsets[i-1]))
-    if (tiledb_version(TRUE) >= "2.6.0") {
-        n_validity <- nfilters(filterlist$validity)
-        validity <- sapply(seq_len(n_validity), function(i) tiledb_filter_type(filterlist$validity[i-1]))
-        validityopts <- sapply(seq_len(n_validity), function(i) .getFilterOption(filterlist$validity[i-1]))
-    }
+    n_validity <- nfilters(filterlist$validity)
+    validity <- sapply(seq_len(n_validity), function(i) tiledb_filter_type(filterlist$validity[i-1]))
+    validityopts <- sapply(seq_len(n_validity), function(i) .getFilterOption(filterlist$validity[i-1]))
 
     arrdesc <- data.frame(uri = uri,
                           type = if (sparse) "sparse" else "dense",
@@ -717,8 +714,8 @@ tiledb_schema_object <- function(array) {
                           coord_options = paste0(coordopts, collapse=","),
                           offset_filters = paste0(offsets, collapse=","),
                           offset_options = paste0(offsetopts, collapse=","),
-                          validity_filters = if (tiledb_version(TRUE) >= "2.6.0") paste0(validity, collapse=",") else "",
-                          validity_options = if (tiledb_version(TRUE) >= "2.6.0") paste0(validityopts, collapse=",") else ""
+                          validity_filters = paste0(validity, collapse=","),
+                          validity_options = paste0(validityopts, collapse=",")
                           )
 
     dims <- dimensions(dom)
@@ -757,7 +754,7 @@ tiledb_schema_object <- function(array) {
         if (nfilters(fltlst) == 0) ""
         else sapply(seq_len(nfilters(fltlst)), function(i) .getFilterOption(fltlst[i-1]))
     }))
-    attrfillvals <- sapply(attrs, function(a) if (tiledb_attribute_get_nullable(a) || tiledb_version(TRUE) < "2.1.0") ""
+    attrfillvals <- sapply(attrs, function(a) if (tiledb_attribute_get_nullable(a)) ""
                                               else format(tiledb_attribute_get_fill_value(a)))
 
     attrdesc <- data.frame(names = attrnames,
@@ -839,12 +836,9 @@ tiledb_schema_object <- function(array) {
         ifelse(sch$offset_filters != "",
                .show_filter_list(sch$offset_filters, sch$offset_options, "\n\t\t\t   offsets_filter_list="),
                "offset_filters=NULL"), ", ",
-        ifelse(tiledb_version(TRUE) >= "2.6.0",
-               ifelse(sch$validity_filters != "",
-                      .show_filter_list(sch$validity_filters, sch$validity_options, "\n\t\t\t   validity_filter_list="),
-                      "validity_filters=NULL"),
-               ""),
-        ")\n",
+        ifelse(sch$validity_filters != "",
+               .show_filter_list(sch$validity_filters, sch$validity_options, "\n\t\t\t   validity_filter_list="),
+               "validity_filters=NULL"), ")\n",
         "tiledb_array_create(uri=tempfile(), schema=sch)) # or assign your URI here\n",
         sep="")
 }

R/ArraySchemaEvolution.R

@@ -1,6 +1,6 @@
 #  MIT License
 #
-#  Copyright (c) 2021 TileDB Inc.
+#  Copyright (c) 2023 TileDB Inc.
 #
 #  Permission is hereby granted, free of charge, to any person obtaining a copy
 #  of this software and associated documentation files (the "Software"), to deal
@@ -34,8 +34,7 @@ setClass("tiledb_array_schema_evolution",
 #' @return A 'array_schema_evolution' object
 #' @export
 tiledb_array_schema_evolution <- function(ctx = tiledb_get_context()) {
-    stopifnot(`The 'ctx' argument must be a Context object` = is(ctx, "tiledb_ctx"),
-              `This function needs TileDB 2.4.0 or newer` = tiledb_version(TRUE) >= "2.4.0")
+    stopifnot(`The 'ctx' argument must be a Context object` = is(ctx, "tiledb_ctx"))
     ptr <- libtiledb_array_schema_evolution(ctx@ptr)
     array_schema_evolution <- new("tiledb_array_schema_evolution", ptr = ptr)
     invisible(array_schema_evolution)

R/BatchedQuery.R

@@ -219,7 +219,7 @@ createBatched <- function(x) {
                 res <- libtiledb_query_get_est_result_size(qryptr, name)
             else if (!is.na(varnum) && nullable)
                 res <- libtiledb_query_get_est_result_size_nullable(qryptr, name)[1]
-            if (rangeunset && tiledb::tiledb_version(TRUE) >= "2.2.0") {
+            if (rangeunset) {
                 sz <- tiledb_datatype_string_to_sizeof(datatype)
                 res <- res / sz
             }

R/Config.R

@@ -1,6 +1,6 @@
 #  MIT License
 #
-#  Copyright (c) 2017-2021 TileDB Inc.
+#  Copyright (c) 2017-2023 TileDB Inc.
 #
 #  Permission is hereby granted, free of charge, to any person obtaining a copy
 #  of this software and associated documentation files (the "Software"), to deal
@@ -234,15 +234,8 @@ limitTileDBCores <- function(ncores, verbose=FALSE) {
   }
   stopifnot(`The 'ncores' argument must be numeric or character` = is.numeric(ncores) || is.character(ncores))
   cfg <- tiledb_config()
-  if (tiledb_version(TRUE) >= "2.1.0") {
-    cfg["sm.compute_concurrency_level"] <- ncores
-    cfg["sm.io_concurrency_level"] <- ncores
-  } else {
-    cfg["sm.num_reader_threads"] <- ncores
-    cfg["sm.num_writer_threads"] <- ncores
-    cfg["vfs.file.max_parallel_ops"] <- ncores
-    cfg["vfs.num_threads"] <- ncores
-  }
+  cfg["sm.compute_concurrency_level"] <- ncores
+  cfg["sm.io_concurrency_level"] <- ncores
   if (verbose) message("Limiting TileDB to ",ncores," cores. See ?limitTileDBCores.")
   invisible(cfg)
 }

R/Ctx.R

@@ -1,6 +1,6 @@
 #  MIT License
 #
-#  Copyright (c) 2017-2021 TileDB Inc.
+#  Copyright (c) 2017-2023 TileDB Inc.
 #
 #  Permission is hereby granted, free of charge, to any person obtaining a copy
 #  of this software and associated documentation files (the "Software"), to deal
@@ -194,7 +194,6 @@ tiledb_ctx_set_default_tags <- function(object) {
 #' @return A JSON-formatted string with context statistics
 #' @export
 tiledb_ctx_stats <- function(object = tiledb_get_context()) {
-    stopifnot(`The 'object' variable must be a TileDB Context object` = is(object, "tiledb_ctx"),
-              `TileDB 2.4.0 or later is required` = tiledb_version(TRUE) >= "2.4.0")
+    stopifnot(`The 'object' variable must be a TileDB Context object` = is(object, "tiledb_ctx"))
     libtiledb_ctx_stats(object@ptr)
 }

R/Error.R

@@ -1,6 +1,6 @@
 #  MIT License
 #
-#  Copyright (c) 2017-2021 TileDB Inc.
+#  Copyright (c) 2017-2023 TileDB Inc.
 #
 #  Permission is hereby granted, free of charge, to any person obtaining a copy
 #  of this software and associated documentation files (the "Software"), to deal
@@ -28,7 +28,6 @@
 #' @return A character variable with the error message
 #' @export
 tiledb_error_message <- function(ctx = tiledb_get_context()) {
-    stopifnot(`The 'ctx' variable must be a TileDB Context object` = is(ctx, "tiledb_ctx"),
-              `TileDB 2.5.0 or later is required` = tiledb_version(TRUE) >= "2.5.0")
+    stopifnot(`The 'ctx' variable must be a TileDB Context object` = is(ctx, "tiledb_ctx"))
     libtiledb_error_message(ctx@ptr)
 }

R/Query.R

@@ -568,8 +568,7 @@ tiledb_get_query_status <- function() {
 #' @return A JSON-formatted string with context statistics
 #' @export
 tiledb_query_stats <- function(query) {
-    stopifnot(`The 'query' argument must be a TileDB Query object` = is(query, "tiledb_query"),
-              `TileDB 2.4.0 or later is required` = tiledb_version(TRUE) >= "2.4.0")
+    stopifnot(`The 'query' argument must be a TileDB Query object` = is(query, "tiledb_query"))
     libtiledb_query_stats(query@ptr)
 }
 
@@ -579,8 +578,7 @@ tiledb_query_stats <- function(query) {
 #' @return A TileDB Context object retrieved from the query
 #' @export
 tiledb_query_ctx <- function(query) {
-    stopifnot(`The 'query' argument must be a TileDB Query object` = is(query, "tiledb_query"),
-              `TileDB 2.6.0 or later is required` = tiledb_version(TRUE) >= "2.6.0")
+    stopifnot(`The 'query' argument must be a TileDB Query object` = is(query, "tiledb_query"))
     new("tiledb_ctx", ptr = libtiledb_query_get_ctx(query@ptr))
 }
 

R/QueryCondition.R

@@ -37,8 +37,7 @@ setClass("tiledb_query_condition",
 #' @return A 'tiledb_query_condition' object
 #' @export
 tiledb_query_condition <- function(ctx = tiledb_get_context()) {
-    stopifnot("The argument must be a ctx object" = is(ctx, "tiledb_ctx"),
-              "This function needs TileDB 2.3.0 or newer" = tiledb_version(TRUE) >= "2.3.0")
+    stopifnot("The argument must be a ctx object" = is(ctx, "tiledb_ctx"))
     ptr <- libtiledb_query_condition(ctx@ptr)
     query_condition <- new("tiledb_query_condition", ptr = ptr, init = FALSE)
     invisible(query_condition)

R/Stats.R

@@ -73,14 +73,10 @@ tiledb_stats_print <- function() {
 #' This function requires TileDB Embedded 2.0.3 or later.
 #' @examples
 #' \dontshow{ctx <- tiledb_ctx(limitTileDBCores())}
-#' if (tiledb_version(TRUE) >= "2.0.3") {
-#'   txt <- tiledb_stats_raw_dump()
-#'   cat(txt, "\n")
-#' }
+#' txt <- tiledb_stats_raw_dump()
+#' cat(txt, "\n")
 #' @export
 tiledb_stats_raw_dump <- function() {
-    stopifnot("Raw statistics are available with TileDB Embedded verion 2.0.3 or later" =
-                  tiledb_version(TRUE) >= "2.0.3")
     libtiledb_stats_raw_dump()
 }
 
@@ -90,8 +86,6 @@ tiledb_stats_raw_dump <- function() {
 #' It required TileDB Embedded 2.0.3 or later.
 #' @export
 tiledb_stats_raw_print <- function() {
-    stopifnot("Raw statistics are available with TileDB Embedded verion 2.0.3 or later"
-              = tiledb_version(TRUE) >= "2.0.3")
     cat(libtiledb_stats_raw_dump(), "\n")
 }
 
@@ -102,8 +96,6 @@ tiledb_stats_raw_print <- function() {
 #' It required TileDB Embedded 2.0.3 or later.
 #' @export
 tiledb_stats_raw_get <- function() {
-    stopifnot("Raw statistics are available with TileDB Embedded verion 2.0.3 or later"
-              = tiledb_version(TRUE) >= "2.0.3")
     .Deprecated(msg="Use 'tiledb_stats_raw_dump' instead of 'tiledb_stats_raw_get'.")
     libtiledb_stats_raw_get()
  }

R/Subarray.R

@@ -1,6 +1,6 @@
 #  MIT License
 #
-#  Copyright (c) 2017-2022 TileDB Inc.
+#  Copyright (c) 2017-2023 TileDB Inc.
 #
 #  Permission is hereby granted, free of charge, to any person obtaining a copy
 #  of this software and associated documentation files (the "Software"), to deal
@@ -39,8 +39,7 @@ tiledb_subarray.from_ptr <- function(ptr) {
 #' @return tiledb_subarray object
 #' @export
 tiledb_subarray <- function(query) {
-    stopifnot("Argument 'query' must be a tiledb_query object" = is(query, "tiledb_query"),
-              "Subarray functionality needs TileDB >= 2.7.0" = tiledb_version(TRUE) >= "2.6.0")
+    stopifnot("Argument 'query' must be a tiledb_query object" = is(query, "tiledb_query"))
     ptr <- libtiledb_subarray(query@ptr)
     return(new("tiledb_subarray", ptr = ptr))
 }

R/TileDBArray.R

@@ -815,7 +815,7 @@ setMethod("[", "tiledb_array",
               res <- libtiledb_query_get_est_result_size_nullable(qryptr, name)[1]
               spdl::debug("[getEstimatedSize] column '{}' (!is.na(varnum) and nullable) {}", name, res)
           }
-          if (rangeunset && tiledb::tiledb_version(TRUE) >= "2.2.0") {
+          if (rangeunset) {
               sz <- tiledb_datatype_string_to_sizeof(datatype)
               res <- res / sz
               spdl::debug("[getEstimatedSize] column '{}' rangeunset and res scaled to {}", name, res)
@@ -1629,15 +1629,13 @@ array_consolidate <- function(uri, cfg = NULL,
     }
 
     if (!missing(start_time)) {
-        stopifnot(`Argument 'start_time' must be datetime object` = inherits(start_time, "POSIXt"),
-                  `TileDB 2.3.0 or later is required`  = tiledb_version(TRUE) >= "2.3.0")
+        stopifnot(`Argument 'start_time' must be datetime object` = inherits(start_time, "POSIXt"))
         start_time_int64 <- bit64::as.integer64(as.numeric(start_time) * 1000)
         cfg["sm.consolidation.timestamp_start"] = as.character(start_time_int64)
     }
 
     if (!missing(end_time)) {
-        stopifnot(`Argument 'end_time' must be datetime object`  = inherits(end_time, "POSIXt"),
-                  `TileDB 2.3.0 or later is required` = tiledb_version(TRUE) >= "2.3.0")
+        stopifnot(`Argument 'end_time' must be datetime object`  = inherits(end_time, "POSIXt"))
         end_time_int64 <- bit64::as.integer64(as.numeric(end_time) * 1000)
         cfg["sm.consolidation.timestamp_end"] = as.character(end_time_int64)
     }
@@ -1673,15 +1671,13 @@ array_vacuum <- function(uri, cfg = NULL,
     }
 
     if (!missing(start_time)) {
-        stopifnot(`Argument 'start_time' must be datetime object` = inherits(start_time, "POSIXt"),
-                  `TileDB 2.3.0 or later is required`  = tiledb_version(TRUE) >= "2.3.0")
+        stopifnot(`Argument 'start_time' must be datetime object` = inherits(start_time, "POSIXt"))
         start_time_int64 <- bit64::as.integer64(as.numeric(start_time) * 1000)
         cfg["sm.consolidation.timestamp_start"] = as.character(start_time_int64)
     }
 
     if (!missing(end_time)) {
-        stopifnot(`Argument 'end_time' must be datetime object` = inherits(end_time, "POSIXt"),
-                  `TileDB 2.3.0 or later is required` = tiledb_version(TRUE) >= "2.3.0")
+        stopifnot(`Argument 'end_time' must be datetime object` = inherits(end_time, "POSIXt"))
         end_time_int64 <- bit64::as.integer64(as.numeric(end_time) * 1000)
         cfg["sm.consolidation.timestamp_end"] = as.character(end_time_int64)
     }