From 8de960edae86730f74e03ed84200a7fc3bc9305f Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Tue, 23 Jul 2024 16:56:57 -0500 Subject: [PATCH 01/10] Add CurrentDomain getter and setter for ArraySchemaExperimental --- R/RcppExports.R | 8 ++++++++ src/RcppExports.cpp | 26 ++++++++++++++++++++++++++ src/libtiledb.cpp | 26 ++++++++++++++++++++++++++ 3 files changed, 60 insertions(+) diff --git a/R/RcppExports.R b/R/RcppExports.R index a71688e41a..061b7b9a3d 100644 --- a/R/RcppExports.R +++ b/R/RcppExports.R @@ -436,6 +436,14 @@ libtiledb_array_schema_set_enumeration_empty <- function(ctx, schema, attr, enum .Call(`_tiledb_libtiledb_array_schema_set_enumeration_empty`, ctx, schema, attr, enum_name, type_str, cell_val_num, ordered) } +libtiledb_array_schema_get_current_domain <- function(ctx, sch) { + .Call(`_tiledb_libtiledb_array_schema_get_current_domain`, ctx, sch) +} + +libtiledb_array_schema_set_current_domain <- function(ctx, sch, cd) { + invisible(.Call(`_tiledb_libtiledb_array_schema_set_current_domain`, ctx, sch, cd)) +} + libtiledb_array_schema_evolution <- function(ctx) { .Call(`_tiledb_libtiledb_array_schema_evolution`, ctx) } diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp index b284fd71fe..a2b45e3c9d 100644 --- a/src/RcppExports.cpp +++ b/src/RcppExports.cpp @@ -1259,6 +1259,30 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// libtiledb_array_schema_get_current_domain +XPtr libtiledb_array_schema_get_current_domain(XPtr ctx, XPtr sch); +RcppExport SEXP _tiledb_libtiledb_array_schema_get_current_domain(SEXP ctxSEXP, SEXP schSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type ctx(ctxSEXP); + Rcpp::traits::input_parameter< XPtr >::type sch(schSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_array_schema_get_current_domain(ctx, sch)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_array_schema_set_current_domain +void libtiledb_array_schema_set_current_domain(XPtr ctx, XPtr sch, XPtr cd); +RcppExport SEXP _tiledb_libtiledb_array_schema_set_current_domain(SEXP ctxSEXP, SEXP schSEXP, SEXP cdSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type ctx(ctxSEXP); + Rcpp::traits::input_parameter< XPtr >::type sch(schSEXP); + Rcpp::traits::input_parameter< XPtr >::type cd(cdSEXP); + libtiledb_array_schema_set_current_domain(ctx, sch, cd); + return R_NilValue; +END_RCPP +} // libtiledb_array_schema_evolution XPtr libtiledb_array_schema_evolution(XPtr ctx); RcppExport SEXP _tiledb_libtiledb_array_schema_evolution(SEXP ctxSEXP) { @@ -3776,6 +3800,8 @@ static const R_CallMethodDef CallEntries[] = { {"_tiledb_libtiledb_array_schema_version", (DL_FUNC) &_tiledb_libtiledb_array_schema_version, 1}, {"_tiledb_libtiledb_array_schema_set_enumeration", (DL_FUNC) &_tiledb_libtiledb_array_schema_set_enumeration, 7}, {"_tiledb_libtiledb_array_schema_set_enumeration_empty", (DL_FUNC) &_tiledb_libtiledb_array_schema_set_enumeration_empty, 7}, + {"_tiledb_libtiledb_array_schema_get_current_domain", (DL_FUNC) &_tiledb_libtiledb_array_schema_get_current_domain, 2}, + {"_tiledb_libtiledb_array_schema_set_current_domain", (DL_FUNC) &_tiledb_libtiledb_array_schema_set_current_domain, 3}, {"_tiledb_libtiledb_array_schema_evolution", (DL_FUNC) &_tiledb_libtiledb_array_schema_evolution, 1}, {"_tiledb_libtiledb_array_schema_evolution_add_attribute", (DL_FUNC) &_tiledb_libtiledb_array_schema_evolution_add_attribute, 2}, {"_tiledb_libtiledb_array_schema_evolution_drop_attribute", (DL_FUNC) &_tiledb_libtiledb_array_schema_evolution_drop_attribute, 2}, diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index 777bd13fe2..af7ed65fd8 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -2118,6 +2118,32 @@ libtiledb_array_schema_set_enumeration_empty(XPtr ctx, return schema; } +// [[Rcpp::export]] +XPtr libtiledb_array_schema_get_current_domain(XPtr ctx, + XPtr sch) { + check_xptr_tag(ctx); + check_xptr_tag(sch); +#if TILEDB_VERSION >= TileDB_Version(2,25,0) + auto cd = tiledb::ArraySchemaExperimental::current_domain(*ctx.get(), *sch.get()); +#else + auto cd = tiledb::CurrentDomain(*ctx.get); +#endif + auto ptr = make_xptr(new tiledb::CurrentDomain(cd)); + return ptr; +} + +// [[Rcpp::export]] +void libtiledb_array_schema_set_current_domain(XPtr ctx, + XPtr sch, + XPtr cd) { + check_xptr_tag(ctx); + check_xptr_tag(sch); + check_xptr_tag(cd); +#if TILEDB_VERSION >= TileDB_Version(2,25,0) + tiledb::ArraySchemaExperimental::set_current_domain(*ctx.get(), *sch.get(), *cd.get()); +#endif +} + /** * TileDB Array Schema Evolution From a7c868798c59daedd448b3e677eec9ca9fb20d5a Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Tue, 23 Jul 2024 16:59:40 -0500 Subject: [PATCH 02/10] Add external pointer tag checks --- src/libtiledb.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index af7ed65fd8..4ff4d569ee 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -5386,6 +5386,8 @@ int32_t libtiledb_mime_type_from_str(std::string mime_type) { // [[Rcpp::export]] XPtr libtiledb_ndrectangle_create(XPtr ctx, XPtr dom) { + check_xptr_tag(ctx); + check_xptr_tag(dom); #if TILEDB_VERSION >= TileDB_Version(2,25,0) auto ndr = new tiledb::NDRectangle(*ctx.get(), *dom.get()); #else @@ -5400,6 +5402,7 @@ XPtr libtiledb_ndrectangle_set_range(XPtr(ndr); #if TILEDB_VERSION >= TileDB_Version(2,25,0) auto dtype = _string_to_tiledb_datatype(datatype); if (dtype == TILEDB_CHAR || // branch for 'string' @@ -5426,6 +5429,7 @@ XPtr libtiledb_ndrectangle_set_range(XPtr ndr, std::string& dimname, std::string& dtype) { + check_xptr_tag(ndr); #if TILEDB_VERSION >= TileDB_Version(2,25,0) if (dtype == "CHAR" || dtype == "ASCII" || dtype == "UTF8") { auto range = ndr->range(dimname); @@ -5455,6 +5459,7 @@ SEXP libtiledb_ndrectangle_get_range(XPtr ndr, // [[Rcpp::export]] XPtr libtiledb_current_domain_create(XPtr ctx) { + check_xptr_tag(ctx); #if TILEDB_VERSION >= TileDB_Version(2,25,0) auto cd = new tiledb::CurrentDomain(*ctx.get()); #else @@ -5466,6 +5471,7 @@ XPtr libtiledb_current_domain_create(XPtr cd) { + check_xptr_tag(cd); #if TILEDB_VERSION >= TileDB_Version(2,25,0) auto tp = cd->type(); auto str = std::string(_tiledb_datatype_to_string(static_cast(tp))); @@ -5478,6 +5484,8 @@ std::string libtiledb_current_domain_type(XPtr cd) { // [[Rcpp::export]] XPtr libtiledb_current_domain_set_ndrectangle(XPtr cd, XPtr ndr) { + check_xptr_tag(cd); + check_xptr_tag(ndr); #if TILEDB_VERSION >= TileDB_Version(2,25,0) cd->set_ndrectangle(*ndr.get()); #endif @@ -5486,6 +5494,7 @@ XPtr libtiledb_current_domain_set_ndrectangle(XPtr libtiledb_current_domain_get_ndrectangle(XPtr cd) { + check_xptr_tag(cd); #if TILEDB_VERSION >= TileDB_Version(2,25,0) auto nd = new tiledb::NDRectangle(cd->ndrectangle()); #else @@ -5498,6 +5507,7 @@ XPtr libtiledb_current_domain_get_ndrectangle(XPtr cd) { + check_xptr_tag(cd); #if TILEDB_VERSION >= TileDB_Version(2,25,0) return cd->is_empty(); #else From f4ce2807ca2d5e69d57946c2586471d3b242dbb2 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Tue, 23 Jul 2024 17:35:17 -0500 Subject: [PATCH 03/10] Two micro corrections --- R/CurrentDomain.R | 3 ++- inst/tinytest/test_current_domain.R | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/R/CurrentDomain.R b/R/CurrentDomain.R index f0ef519918..35f1f26007 100644 --- a/R/CurrentDomain.R +++ b/R/CurrentDomain.R @@ -66,7 +66,8 @@ tiledb_current_domain_set_ndrectangle <- function(cd, ndr) { is(cd, "tiledb_current_domain"), "The second argument must be a TileDB NDRectangle object" = is(ndr, "tiledb_ndrectangle"), "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") - libtiledb_current_domain_set_ndrectangle(cd@ptr, ndr@ptr) + cd@ptr <- libtiledb_current_domain_set_ndrectangle(cd@ptr, ndr@ptr) + cd } #' Get a `tiledb_ndrectangle` from a `tiledb_current_domain` object diff --git a/inst/tinytest/test_current_domain.R b/inst/tinytest/test_current_domain.R index a7009d2237..565cf27576 100644 --- a/inst/tinytest/test_current_domain.R +++ b/inst/tinytest/test_current_domain.R @@ -8,7 +8,7 @@ if (tiledb_version(TRUE) < "2.25.0") exit_file("These tests needs TileDB 2.25.0 expect_silent(intdim <- tiledb_dim("dim", c(1L, 100L), type = "INT32")) expect_silent(intdom <- tiledb_domain(dim = intdim)) expect_silent(ndr <- tiledb_ndrectangle(intdom)) -expect_silent(tiledb_ndrectangle_set_range(ndr, "dim", 41L, 42L)) # wrong type +expect_silent(tiledb_ndrectangle_set_range(ndr, "dim", 41L, 42L)) expect_silent(cd <- tiledb_current_domain()) expect_true(tiledb_current_domain_is_empty(cd)) From 553dd8a051bd9273e0a614df41dd75652b3d907c Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Tue, 23 Jul 2024 19:41:38 -0500 Subject: [PATCH 04/10] R functions to set and get current domain to and from schema --- NAMESPACE | 2 ++ R/ArraySchema.R | 31 ++++++++++++++++++- man/tiledb_array_schema_get_current_domain.Rd | 19 ++++++++++++ man/tiledb_array_schema_set_current_domain.Rd | 21 +++++++++++++ 4 files changed, 72 insertions(+), 1 deletion(-) create mode 100644 man/tiledb_array_schema_get_current_domain.Rd create mode 100644 man/tiledb_array_schema_set_current_domain.Rd diff --git a/NAMESPACE b/NAMESPACE index 7dad37415b..81385fc048 100644 --- a/NAMESPACE +++ b/NAMESPACE @@ -108,9 +108,11 @@ export(tiledb_array_schema_evolution_drop_enumeration) export(tiledb_array_schema_evolution_extend_enumeration) export(tiledb_array_schema_get_allows_dups) export(tiledb_array_schema_get_capacity) +export(tiledb_array_schema_get_current_domain) export(tiledb_array_schema_set_allows_dups) export(tiledb_array_schema_set_capacity) export(tiledb_array_schema_set_coords_filter_list) +export(tiledb_array_schema_set_current_domain) export(tiledb_array_schema_set_enumeration_empty) export(tiledb_array_schema_set_offsets_filter_list) export(tiledb_array_schema_set_validity_filter_list) diff --git a/R/ArraySchema.R b/R/ArraySchema.R index dabdf9a293..29ed9baaa4 100644 --- a/R/ArraySchema.R +++ b/R/ArraySchema.R @@ -1,6 +1,6 @@ # MIT License # -# Copyright (c) 2017-2023 TileDB Inc. +# Copyright (c) 2017-2024 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 @@ -906,3 +906,32 @@ tiledb_array_schema_set_enumeration_empty <- function(schema, attr, enum_name, ordered) schema } + +#' Get the Current Domain of an Array Schema +#' +#' Note that 'CurrendDomain' object may be empty. +#' @param schema An Array Schema +#' @param ctx Optional tiledb_ctx object +#' @return A 'CurrendDomain' object +#' @export +tiledb_array_schema_get_current_domain <- function(schema, ctx = tiledb_get_context()) { + stopifnot("Argument 'schema' must be a 'tiledb_array_schema'" = is(schema, "tiledb_array_schema"), + "Argument 'ctx' must be a 'tiledb_ctx'" = is(ctx, "tiledb_ctx")) + cdptr <- libtiledb_array_schema_get_current_domain(ctx@ptr, schema@ptr) + new("tiledb_current_domain", ptr=cdptr) +} + +#' Set a Current Domain of an Array Schema +#' +#' @param schema An Array Schema +#' @param cd An CurrendDomain object +#' @param ctx Optional tiledb_ctx object +#' @return Nothing is returned from this function (but an error, should it occur is reported) +#' @export +tiledb_array_schema_set_current_domain <- function(schema, cd, ctx = tiledb_get_context()) { + stopifnot("Argument 'schema' must be a 'tiledb_array_schema'" = is(schema, "tiledb_array_schema"), + "Argument 'cd' must be a 'tiledb_current_domain'" = is(cd, "tiledb_current_domain"), + "Argument 'ctx' must be a 'tiledb_ctx'" = is(ctx, "tiledb_ctx")) + libtiledb_array_schema_set_current_domain(ctx@ptr, schema@ptr, cd@ptr) + invisible(NULL) +} diff --git a/man/tiledb_array_schema_get_current_domain.Rd b/man/tiledb_array_schema_get_current_domain.Rd new file mode 100644 index 0000000000..b7581a02f9 --- /dev/null +++ b/man/tiledb_array_schema_get_current_domain.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/ArraySchema.R +\name{tiledb_array_schema_get_current_domain} +\alias{tiledb_array_schema_get_current_domain} +\title{Get the Current Domain of an Array Schema} +\usage{ +tiledb_array_schema_get_current_domain(schema, ctx = tiledb_get_context()) +} +\arguments{ +\item{schema}{An Array Schema} + +\item{ctx}{Optional tiledb_ctx object} +} +\value{ +A 'CurrendDomain' object +} +\description{ +Note that 'CurrendDomain' object may be empty. +} diff --git a/man/tiledb_array_schema_set_current_domain.Rd b/man/tiledb_array_schema_set_current_domain.Rd new file mode 100644 index 0000000000..88b02ce7d7 --- /dev/null +++ b/man/tiledb_array_schema_set_current_domain.Rd @@ -0,0 +1,21 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/ArraySchema.R +\name{tiledb_array_schema_set_current_domain} +\alias{tiledb_array_schema_set_current_domain} +\title{Set a Current Domain of an Array Schema} +\usage{ +tiledb_array_schema_set_current_domain(schema, cd, ctx = tiledb_get_context()) +} +\arguments{ +\item{schema}{An Array Schema} + +\item{cd}{An CurrendDomain object} + +\item{ctx}{Optional tiledb_ctx object} +} +\value{ +Nothing is returned from this function (but an error, should it occur is reported) +} +\description{ +Set a Current Domain of an Array Schema +} From c42433de325d290c56b764228297b95da2438f89 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Tue, 23 Jul 2024 20:34:05 -0500 Subject: [PATCH 05/10] Correction for older than 2.25.0 build --- src/libtiledb.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index 4ff4d569ee..ecb6782bf0 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -2126,7 +2126,7 @@ XPtr libtiledb_array_schema_get_current_domain(XPtr= TileDB_Version(2,25,0) auto cd = tiledb::ArraySchemaExperimental::current_domain(*ctx.get(), *sch.get()); #else - auto cd = tiledb::CurrentDomain(*ctx.get); + auto cd = tiledb::CurrentDomain(); #endif auto ptr = make_xptr(new tiledb::CurrentDomain(cd)); return ptr; From 49e3abc9c128993b45bc495ca4244af93d0db695 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Tue, 23 Jul 2024 20:44:43 -0500 Subject: [PATCH 06/10] Ensure new examples are versioned --- R/CurrentDomain.R | 4 +++- R/NDRectangle.R | 28 ++++++++++++++++------------ man/tiledb_current_domain.Rd | 4 +++- man/tiledb_ndrectangle.Rd | 10 ++++++---- man/tiledb_ndrectangle_get_range.Rd | 11 ++++++----- man/tiledb_ndrectangle_set_range.Rd | 9 +++++---- src/libtiledb.cpp | 6 +++--- 7 files changed, 42 insertions(+), 30 deletions(-) diff --git a/R/CurrentDomain.R b/R/CurrentDomain.R index 35f1f26007..a67354f994 100644 --- a/R/CurrentDomain.R +++ b/R/CurrentDomain.R @@ -33,7 +33,9 @@ setClass("tiledb_current_domain", #' @return The `tiledb_current_domain` object #' @examples #' \dontshow{ctx <- tiledb_ctx(limitTileDBCores())} -#' cd <-tiledb_current_domain() +#' if (tiledb_version(TRUE) >= "2.25.0") { +#' cd <-tiledb_current_domain() +#' } #' #' @export tiledb_current_domain <- function(ctx = tiledb_get_context()) { diff --git a/R/NDRectangle.R b/R/NDRectangle.R index 8568dea51c..de36f557db 100644 --- a/R/NDRectangle.R +++ b/R/NDRectangle.R @@ -31,13 +31,15 @@ setClass("tiledb_ndrectangle", #' Creates a `tiledb_ndrectangle` object #' -#' @param domain A TileDB Domain object for which the NDRectangle object is created +#' @param dom A TileDB Domain object for which the NDRectangle object is created #' @param ctx (optional) A TileDB Ctx object #' @return The `tiledb_ndrectangle` object #' @examples #' \dontshow{ctx <- tiledb_ctx(limitTileDBCores())} -#' dom <-tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) -#' ndr <- tiledb_ndrectangle(dom) +#' if (tiledb_version(TRUE) >= "2.25.0") { +#' dom <-tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) +#' ndr <- tiledb_ndrectangle(dom) +#' } #' #' @export tiledb_ndrectangle <- function(dom, ctx = tiledb_get_context()) { @@ -62,10 +64,11 @@ tiledb_ndrectangle <- function(dom, ctx = tiledb_get_context()) { #' string dimensions. #' @examples #' \dontshow{ctx <- tiledb_ctx(limitTileDBCores())} -#' dom <-tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) -#' ndr <- tiledb_ndrectangle(dom) -#' ndr <- tiledb_ndrectangle_set_range(ndr, "d1", 50, 500) -#' +#' if (tiledb_version(TRUE) >= "2.25.0") { +#' dom <-tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) +#' ndr <- tiledb_ndrectangle(dom) +#' ndr <- tiledb_ndrectangle_set_range(ndr, "d1", 50, 500) +#' } #' @export tiledb_ndrectangle_set_range <- function(ndr, dimname, start, end) { stopifnot("The first argument must be a TileDB NDRectangle object" = is(ndr, "tiledb_ndrectangle"), @@ -86,11 +89,12 @@ tiledb_ndrectangle_set_range <- function(ndr, dimname, start, end) { #' @return The `tiledb_ndrectangle` range as a two-element vector #' @examples #' \dontshow{ctx <- tiledb_ctx(limitTileDBCores())} -#' dom <- tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) -#' ndr <- tiledb_ndrectangle(dom) -#' ndr <- tiledb_ndrectangle_set_range(ndr, "d1", 50, 500) -#' tiledb_ndrectangle_get_range(ndr, "d1") -#' +#' if (tiledb_version(TRUE) >= "2.25.0") { +#' dom <- tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) +#' ndr <- tiledb_ndrectangle(dom) +#' ndr <- tiledb_ndrectangle_set_range(ndr, "d1", 50, 500) +#' tiledb_ndrectangle_get_range(ndr, "d1") +#' } #' @export tiledb_ndrectangle_get_range <- function(ndr, dimname) { stopifnot("The first argument must be a TileDB NDRectangle object" = is(ndr, "tiledb_ndrectangle"), diff --git a/man/tiledb_current_domain.Rd b/man/tiledb_current_domain.Rd index ed99bd30de..510fc84788 100644 --- a/man/tiledb_current_domain.Rd +++ b/man/tiledb_current_domain.Rd @@ -17,6 +17,8 @@ Creates a \code{tiledb_current_domain} object } \examples{ \dontshow{ctx <- tiledb_ctx(limitTileDBCores())} -cd <-tiledb_current_domain() +if (tiledb_version(TRUE) >= "2.25.0") { + cd <-tiledb_current_domain() +} } diff --git a/man/tiledb_ndrectangle.Rd b/man/tiledb_ndrectangle.Rd index df99d12476..d2e2bfd5d5 100644 --- a/man/tiledb_ndrectangle.Rd +++ b/man/tiledb_ndrectangle.Rd @@ -7,9 +7,9 @@ tiledb_ndrectangle(dom, ctx = tiledb_get_context()) } \arguments{ -\item{ctx}{(optional) A TileDB Ctx object} +\item{dom}{A TileDB Domain object for which the NDRectangle object is created} -\item{domain}{A TileDB Domain object for which the NDRectangle object is created} +\item{ctx}{(optional) A TileDB Ctx object} } \value{ The \code{tiledb_ndrectangle} object @@ -19,7 +19,9 @@ Creates a \code{tiledb_ndrectangle} object } \examples{ \dontshow{ctx <- tiledb_ctx(limitTileDBCores())} -dom <-tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) -ndr <- tiledb_ndrectangle(dom) +if (tiledb_version(TRUE) >= "2.25.0") { + dom <-tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) + ndr <- tiledb_ndrectangle(dom) +} } diff --git a/man/tiledb_ndrectangle_get_range.Rd b/man/tiledb_ndrectangle_get_range.Rd index 20cc11230d..dccdbd80a6 100644 --- a/man/tiledb_ndrectangle_get_range.Rd +++ b/man/tiledb_ndrectangle_get_range.Rd @@ -19,9 +19,10 @@ Get a range from a \code{tiledb_ndrectangle} object } \examples{ \dontshow{ctx <- tiledb_ctx(limitTileDBCores())} -dom <- tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) -ndr <- tiledb_ndrectangle(dom) -ndr <- tiledb_ndrectangle_set_range(ndr, "d1", 50, 500) -tiledb_ndrectangle_get_range(ndr, "d1") - +if (tiledb_version(TRUE) >= "2.25.0") { + dom <- tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) + ndr <- tiledb_ndrectangle(dom) + ndr <- tiledb_ndrectangle_set_range(ndr, "d1", 50, 500) + tiledb_ndrectangle_get_range(ndr, "d1") +} } diff --git a/man/tiledb_ndrectangle_set_range.Rd b/man/tiledb_ndrectangle_set_range.Rd index d1f459d2c7..ea65cf3dd6 100644 --- a/man/tiledb_ndrectangle_set_range.Rd +++ b/man/tiledb_ndrectangle_set_range.Rd @@ -27,8 +27,9 @@ Set a range on a \code{tiledb_ndrectangle} object } \examples{ \dontshow{ctx <- tiledb_ctx(limitTileDBCores())} -dom <-tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) -ndr <- tiledb_ndrectangle(dom) -ndr <- tiledb_ndrectangle_set_range(ndr, "d1", 50, 500) - +if (tiledb_version(TRUE) >= "2.25.0") { + dom <-tiledb_domain(dim = tiledb_dim("d1", c(1L, 100L), type = "INT32")) + ndr <- tiledb_ndrectangle(dom) + ndr <- tiledb_ndrectangle_set_range(ndr, "d1", 50, 500) +} } diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index ecb6782bf0..9cfca17a16 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -1231,7 +1231,7 @@ void libtiledb_domain_dump(XPtr domain) { #if TILEDB_VERSION >= TileDB_Version(2,25,0) std::stringstream ss; ss << *domain; - std::cout << ss.str(); + Rcpp::Rcout << ss.str(); #else domain->dump(); #endif @@ -1532,7 +1532,7 @@ void libtiledb_attribute_dump(XPtr attr) { #if TILEDB_VERSION >= TileDB_Version(2,25,0) std::stringstream ss; ss << *attr; - std::cout << ss.str(); + Rcpp::Rcout << ss.str(); #else attr->dump(); #endif @@ -2055,7 +2055,7 @@ void libtiledb_array_schema_dump(XPtr schema) { #if TILEDB_VERSION >= TileDB_Version(2,25,0) std::stringstream ss; ss << *schema; - std::cout << ss.str(); + Rcpp::Rcout << ss.str(); #else schema->dump(); #endif From e031613afcbc6f042c3c6261503b5c25a9091d49 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Wed, 24 Jul 2024 14:08:50 -0500 Subject: [PATCH 07/10] Array Schema and Array Schema Evolution support --- NAMESPACE | 1 + R/ArraySchemaEvolution.R | 16 ++++++++++++++++ R/RcppExports.R | 4 ++++ ..._schema_evolution_expand_current_domain.Rd | 19 +++++++++++++++++++ ...ray_schema_evolution_extend_enumeration.Rd | 3 +++ src/RcppExports.cpp | 13 +++++++++++++ src/libtiledb.cpp | 12 ++++++++++++ 7 files changed, 68 insertions(+) create mode 100644 man/tiledb_array_schema_evolution_expand_current_domain.Rd diff --git a/NAMESPACE b/NAMESPACE index 81385fc048..27a4403b82 100644 --- a/NAMESPACE +++ b/NAMESPACE @@ -105,6 +105,7 @@ export(tiledb_array_schema_evolution_add_enumeration_empty) export(tiledb_array_schema_evolution_array_evolve) export(tiledb_array_schema_evolution_drop_attribute) export(tiledb_array_schema_evolution_drop_enumeration) +export(tiledb_array_schema_evolution_expand_current_domain) export(tiledb_array_schema_evolution_extend_enumeration) export(tiledb_array_schema_get_allows_dups) export(tiledb_array_schema_get_capacity) diff --git a/R/ArraySchemaEvolution.R b/R/ArraySchemaEvolution.R index f7470d1dbe..d288669dd6 100644 --- a/R/ArraySchemaEvolution.R +++ b/R/ArraySchemaEvolution.R @@ -160,6 +160,7 @@ tiledb_array_schema_evolution_add_enumeration_empty <- function(ase, enum_name, #' @param ordered A logical value indicating standard \code{factor} (when \code{FALSE}, the default) #' or \code{ordered} (when \code{TRUE}) #' @param ctx Optional tiledb_ctx object +#' @return The modified ArraySchemaEvolution object #' @export tiledb_array_schema_evolution_extend_enumeration <- function(ase, array, enum_name, new_values, nullable = FALSE, @@ -178,3 +179,18 @@ tiledb_array_schema_evolution_extend_enumeration <- function(ase, array, enum_na nullable, ordered) ase } + +#' Expand an the Current Domain of an Array via Array Schema Evolution +#' +#' @param ase An ArraySchemaEvolution object +#' @param cd A CurrentDomain object +#' @return The modified ArraySchemaEvolution object +#' @export +tiledb_array_schema_evolution_expand_current_domain <- function(ase, cd) { + stopifnot("Argument 'ase' must be an Array Schema Evolution object" = + is(ase, "tiledb_array_schema_evolution"), + "Argument 'cd' must be a CurrentDomain object" = is(cd, "tiledb_current_domain"), + "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") + ase@ptr <- libtiledb_array_schema_evolution_expand_current_domain(ase@ptr, cd@ptr) + ase +} diff --git a/R/RcppExports.R b/R/RcppExports.R index 061b7b9a3d..ab8151e2ef 100644 --- a/R/RcppExports.R +++ b/R/RcppExports.R @@ -476,6 +476,10 @@ libtiledb_array_schema_evolution_extend_enumeration <- function(ctx, ase, array, .Call(`_tiledb_libtiledb_array_schema_evolution_extend_enumeration`, ctx, ase, array, enum_name, new_values, nullable, ordered) } +libtiledb_array_schema_evolution_expand_current_domain <- function(ase, cd) { + .Call(`_tiledb_libtiledb_array_schema_evolution_expand_current_domain`, ase, cd) +} + libtiledb_array_create <- function(uri, schema) { .Call(`_tiledb_libtiledb_array_create`, uri, schema) } diff --git a/man/tiledb_array_schema_evolution_expand_current_domain.Rd b/man/tiledb_array_schema_evolution_expand_current_domain.Rd new file mode 100644 index 0000000000..b1a65a7a95 --- /dev/null +++ b/man/tiledb_array_schema_evolution_expand_current_domain.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/ArraySchemaEvolution.R +\name{tiledb_array_schema_evolution_expand_current_domain} +\alias{tiledb_array_schema_evolution_expand_current_domain} +\title{Expand an the Current Domain of an Array via Array Schema Evolution} +\usage{ +tiledb_array_schema_evolution_expand_current_domain(ase, cd) +} +\arguments{ +\item{ase}{An ArraySchemaEvolution object} + +\item{cd}{A CurrentDomain object} +} +\value{ +The modified ArraySchemaEvolution object +} +\description{ +Expand an the Current Domain of an Array via Array Schema Evolution +} diff --git a/man/tiledb_array_schema_evolution_extend_enumeration.Rd b/man/tiledb_array_schema_evolution_extend_enumeration.Rd index 387afac308..5d60e48aa7 100644 --- a/man/tiledb_array_schema_evolution_extend_enumeration.Rd +++ b/man/tiledb_array_schema_evolution_extend_enumeration.Rd @@ -31,6 +31,9 @@ or \code{ordered} (when \code{TRUE})} \item{ctx}{Optional tiledb_ctx object} } +\value{ +The modified ArraySchemaEvolution object +} \description{ Extend an Evolution via Array Schema Evolution } diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp index a2b45e3c9d..e189472e80 100644 --- a/src/RcppExports.cpp +++ b/src/RcppExports.cpp @@ -1391,6 +1391,18 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// libtiledb_array_schema_evolution_expand_current_domain +XPtr libtiledb_array_schema_evolution_expand_current_domain(XPtr ase, XPtr cd); +RcppExport SEXP _tiledb_libtiledb_array_schema_evolution_expand_current_domain(SEXP aseSEXP, SEXP cdSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type ase(aseSEXP); + Rcpp::traits::input_parameter< XPtr >::type cd(cdSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_array_schema_evolution_expand_current_domain(ase, cd)); + return rcpp_result_gen; +END_RCPP +} // libtiledb_array_create std::string libtiledb_array_create(std::string uri, XPtr schema); RcppExport SEXP _tiledb_libtiledb_array_create(SEXP uriSEXP, SEXP schemaSEXP) { @@ -3810,6 +3822,7 @@ static const R_CallMethodDef CallEntries[] = { {"_tiledb_libtiledb_array_schema_evolution_add_enumeration_empty", (DL_FUNC) &_tiledb_libtiledb_array_schema_evolution_add_enumeration_empty, 6}, {"_tiledb_libtiledb_array_schema_evolution_drop_enumeration", (DL_FUNC) &_tiledb_libtiledb_array_schema_evolution_drop_enumeration, 2}, {"_tiledb_libtiledb_array_schema_evolution_extend_enumeration", (DL_FUNC) &_tiledb_libtiledb_array_schema_evolution_extend_enumeration, 7}, + {"_tiledb_libtiledb_array_schema_evolution_expand_current_domain", (DL_FUNC) &_tiledb_libtiledb_array_schema_evolution_expand_current_domain, 2}, {"_tiledb_libtiledb_array_create", (DL_FUNC) &_tiledb_libtiledb_array_create, 2}, {"_tiledb_libtiledb_array_open", (DL_FUNC) &_tiledb_libtiledb_array_open, 3}, {"_tiledb_libtiledb_array_open_at", (DL_FUNC) &_tiledb_libtiledb_array_open_at, 4}, diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index 9cfca17a16..a1b4791afb 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -2264,6 +2264,18 @@ libtiledb_array_schema_evolution_extend_enumeration(XPtr ctx, return ase; } +//[[Rcpp::export]] +XPtr +libtiledb_array_schema_evolution_expand_current_domain(XPtr ase, + XPtr cd) { + check_xptr_tag(ase); + check_xptr_tag(cd); +#if TILEDB_VERSION >= TileDB_Version(2,25,0) + ase->expand_current_domain(*cd.get()); +#endif + return ase; +} + /** * TileDB Array From f982ecfe3a37a1be73427282a781201a94538b80 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Wed, 24 Jul 2024 17:49:34 -0500 Subject: [PATCH 08/10] Correct current domain data type use --- R/ArraySchema.R | 2 +- R/CurrentDomain.R | 9 ++++++--- ...t_current_domain.R => test_currentdomain.R} | 2 +- src/libtiledb.cpp | 18 +++++++++++++++++- 4 files changed, 25 insertions(+), 6 deletions(-) rename inst/tinytest/{test_current_domain.R => test_currentdomain.R} (92%) diff --git a/R/ArraySchema.R b/R/ArraySchema.R index 29ed9baaa4..14d8361e8f 100644 --- a/R/ArraySchema.R +++ b/R/ArraySchema.R @@ -918,7 +918,7 @@ tiledb_array_schema_get_current_domain <- function(schema, ctx = tiledb_get_cont stopifnot("Argument 'schema' must be a 'tiledb_array_schema'" = is(schema, "tiledb_array_schema"), "Argument 'ctx' must be a 'tiledb_ctx'" = is(ctx, "tiledb_ctx")) cdptr <- libtiledb_array_schema_get_current_domain(ctx@ptr, schema@ptr) - new("tiledb_current_domain", ptr=cdptr) + new("tiledb_current_domain", ptr=cdptr, datatype=datatype(domain(schema))) } #' Set a Current Domain of an Array Schema diff --git a/R/CurrentDomain.R b/R/CurrentDomain.R index a67354f994..4d18e2fb16 100644 --- a/R/CurrentDomain.R +++ b/R/CurrentDomain.R @@ -23,9 +23,11 @@ #' An S4 class for a TileDB CurrentDomain object #' #' @slot ptr An external pointer to the underlying CurrentDomain object +#' @slot datatype An character variable describing the data type of the domain #' @exportClass tiledb_current_domain setClass("tiledb_current_domain", - slots = list(ptr = "externalptr")) + slots = list(ptr = "externalptr", + datatype = "character")) #' Creates a `tiledb_current_domain` object #' @@ -42,7 +44,7 @@ tiledb_current_domain <- function(ctx = tiledb_get_context()) { stopifnot("The first argment must be a TileDB Ctx object" = is(ctx, "tiledb_ctx"), "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") ptr <- libtiledb_current_domain_create(ctx@ptr) - return(new("tiledb_current_domain", ptr = ptr)) + return(new("tiledb_current_domain", ptr = ptr, datatype = NA_character_)) } #' Get `tiledb_current_domain` data type as string @@ -69,6 +71,7 @@ tiledb_current_domain_set_ndrectangle <- function(cd, ndr) { "The second argument must be a TileDB NDRectangle object" = is(ndr, "tiledb_ndrectangle"), "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") cd@ptr <- libtiledb_current_domain_set_ndrectangle(cd@ptr, ndr@ptr) + cd@datatype <- ndr@datatype cd } @@ -82,7 +85,7 @@ tiledb_current_domain_get_ndrectangle <- function(cd) { is(cd, "tiledb_current_domain"), "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") ptr <- libtiledb_current_domain_get_ndrectangle(cd@ptr) - tpstr <- libtiledb_current_domain_type(cd@ptr) + tpstr <- cd@datatype #libtiledb_current_domain_type(cd@ptr) return(new("tiledb_ndrectangle", ptr = ptr, datatype = tpstr)) } diff --git a/inst/tinytest/test_current_domain.R b/inst/tinytest/test_currentdomain.R similarity index 92% rename from inst/tinytest/test_current_domain.R rename to inst/tinytest/test_currentdomain.R index 565cf27576..3fdae1030a 100644 --- a/inst/tinytest/test_current_domain.R +++ b/inst/tinytest/test_currentdomain.R @@ -14,7 +14,7 @@ expect_silent(cd <- tiledb_current_domain()) expect_true(tiledb_current_domain_is_empty(cd)) expect_error(tiledb_current_domain_get_type(cd)) -expect_silent(tiledb_current_domain_set_ndrectangle(cd, ndr)) +expect_silent(cd <- tiledb_current_domain_set_ndrectangle(cd, ndr)) expect_silent(newndr <- tiledb_current_domain_get_ndrectangle(cd)) expect_silent(newtp <- tiledb_current_domain_get_type(cd)) expect_true(is(newndr, "tiledb_ndrectangle")) diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index a1b4791afb..bbfd0e28c3 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -471,6 +471,22 @@ tiledb_vfs_mode_t _string_to_tiledb_vfs_mode_t(std::string modestr) { } } +std::string _tiledb_current_domain_type_to_string(tiledb_current_domain_type_t type) { + if (type == TILEDB_NDRECTANGLE) { + return std::string{"NDRECTANGLE"}; + } else { + Rcpp::stop("Unknown TileDB CurrentDomain type (%d)", (int32_t) type); + } +} + +tiledb_current_domain_type_t _string_to_tiledb_current_domain_type(std::string typestr) { + if (typestr == "NDRECTANGLE") { + return TILEDB_NDRECTANGLE; + } else { + Rcpp::stop("Unknown TileDB CurrentDomain type '%s'", typestr.c_str()); + } +} + // NB Limited type coverage here as aimed to sizing R allocations of either int, double or char // Also note that there is 'inline size_t type_size(tiledb_datatype_t type)' in core_interface.h const size_t _tiledb_datatype_sizeof(const tiledb_datatype_t dtype) { @@ -5486,7 +5502,7 @@ std::string libtiledb_current_domain_type(XPtr cd) { check_xptr_tag(cd); #if TILEDB_VERSION >= TileDB_Version(2,25,0) auto tp = cd->type(); - auto str = std::string(_tiledb_datatype_to_string(static_cast(tp))); + auto str = std::string(_tiledb_current_domain_type_to_string(tp)); return str; #else return std::string(); From b667f61ea18f4286c79809aa5f294113e3d80254 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Thu, 25 Jul 2024 12:32:13 -0500 Subject: [PATCH 09/10] Complete CurrentDomain support with extended tests --- R/ArraySchema.R | 4 +- R/CurrentDomain.R | 3 +- R/NDRectangle.R | 7 +++- inst/tinytest/test_arrayschema.R | 14 +++++-- inst/tinytest/test_arrayschemaevolution.R | 15 ++++++++ inst/tinytest/test_currentdomain.R | 47 +++++++++++++++++++++++ src/libtiledb.cpp | 2 +- 7 files changed, 84 insertions(+), 8 deletions(-) diff --git a/R/ArraySchema.R b/R/ArraySchema.R index 14d8361e8f..ca4da5e3fd 100644 --- a/R/ArraySchema.R +++ b/R/ArraySchema.R @@ -918,7 +918,9 @@ tiledb_array_schema_get_current_domain <- function(schema, ctx = tiledb_get_cont stopifnot("Argument 'schema' must be a 'tiledb_array_schema'" = is(schema, "tiledb_array_schema"), "Argument 'ctx' must be a 'tiledb_ctx'" = is(ctx, "tiledb_ctx")) cdptr <- libtiledb_array_schema_get_current_domain(ctx@ptr, schema@ptr) - new("tiledb_current_domain", ptr=cdptr, datatype=datatype(domain(schema))) + typestr <- datatype(domain(schema)) + names(typestr) <- sapply(dimensions(domain(schema)), name) + new("tiledb_current_domain", ptr=cdptr, datatype=typestr) } #' Set a Current Domain of an Array Schema diff --git a/R/CurrentDomain.R b/R/CurrentDomain.R index 4d18e2fb16..203b2520b9 100644 --- a/R/CurrentDomain.R +++ b/R/CurrentDomain.R @@ -70,6 +70,7 @@ tiledb_current_domain_set_ndrectangle <- function(cd, ndr) { is(cd, "tiledb_current_domain"), "The second argument must be a TileDB NDRectangle object" = is(ndr, "tiledb_ndrectangle"), "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") + spdl::debug("[tiledb_current_domain_set_ndrectangle] before libtile call") cd@ptr <- libtiledb_current_domain_set_ndrectangle(cd@ptr, ndr@ptr) cd@datatype <- ndr@datatype cd @@ -85,7 +86,7 @@ tiledb_current_domain_get_ndrectangle <- function(cd) { is(cd, "tiledb_current_domain"), "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") ptr <- libtiledb_current_domain_get_ndrectangle(cd@ptr) - tpstr <- cd@datatype #libtiledb_current_domain_type(cd@ptr) + tpstr <- cd@datatype return(new("tiledb_ndrectangle", ptr = ptr, datatype = tpstr)) } diff --git a/R/NDRectangle.R b/R/NDRectangle.R index de36f557db..6382795ad5 100644 --- a/R/NDRectangle.R +++ b/R/NDRectangle.R @@ -47,6 +47,7 @@ tiledb_ndrectangle <- function(dom, ctx = tiledb_get_context()) { "The second argment must be a TileDB Ctx object" = is(ctx, "tiledb_ctx"), "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") typestr <- datatype(dom) + names(typestr) <- sapply(dimensions(dom), name) ptr <- libtiledb_ndrectangle_create(ctx@ptr, dom@ptr) return(new("tiledb_ndrectangle", ptr = ptr, datatype = typestr)) } @@ -78,7 +79,8 @@ tiledb_ndrectangle_set_range <- function(ndr, dimname, start, end) { "The fourth argument must be scalar" = length(end) == 1, "The fourth and first argument must be of the same class" = class(start) == class(end), "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") - ndr@ptr <- libtiledb_ndrectangle_set_range(ndr@ptr, ndr@datatype, dimname, start, end) + dtype <- unname(ndr@datatype[dimname]) + ndr@ptr <- libtiledb_ndrectangle_set_range(ndr@ptr, dtype, dimname, start, end) invisible(ndr) } @@ -101,6 +103,7 @@ tiledb_ndrectangle_get_range <- function(ndr, dimname) { "The second argument must a single character object" = is.character(dimname) && length(dimname) == 1, "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") - rng <- libtiledb_ndrectangle_get_range(ndr@ptr, dimname, ndr@datatype) + dtype <- unname(ndr@datatype[dimname]) + rng <- libtiledb_ndrectangle_get_range(ndr@ptr, dimname, dtype) rng } diff --git a/inst/tinytest/test_arrayschema.R b/inst/tinytest/test_arrayschema.R index 8863aa9669..50403df1ad 100644 --- a/inst/tinytest/test_arrayschema.R +++ b/inst/tinytest/test_arrayschema.R @@ -130,9 +130,8 @@ ctx <- tiledb_ctx(oldconfig) # reset to no encryption via previous config #test_that("tiledb_array_schema dups setter/getter", { dom <- tiledb_domain(dims = c(tiledb_dim("rows", c(1L, 4L), 4L, "INT32"), tiledb_dim("cols", c(1L, 4L), 4L, "INT32"))) -sch <- tiledb_array_schema(dom, - attrs = c(tiledb_attr("a", type = "INT32")), - sparse = TRUE) +attr <- tiledb_attr("a", type = "INT32") +sch <- tiledb_array_schema(dom, attrs = attr, sparse = TRUE) ## false by default expect_false(allows_dups(sch)) @@ -141,3 +140,12 @@ expect_false(allows_dups(sch)) allows_dups(sch) <- TRUE expect_true(allows_dups(sch)) #}) + + +## current domain +expect_error(tiledb_array_schema_get_current_domain(dom)) # wrong object +expect_silent(cd <- tiledb_array_schema_get_current_domain(sch)) +expect_silent(tiledb_array_schema_set_current_domain(sch, cd)) + +dsch <- tiledb_array_schema(dom, attrs = attr, sparse = FALSE) +expect_error(tiledb_array_schema_set_current_domain(dsch, cd)) # not for dense diff --git a/inst/tinytest/test_arrayschemaevolution.R b/inst/tinytest/test_arrayschemaevolution.R index 40ffb7d0c8..f483327f14 100644 --- a/inst/tinytest/test_arrayschemaevolution.R +++ b/inst/tinytest/test_arrayschemaevolution.R @@ -255,3 +255,18 @@ v <- res[["val"]]$as_vector() expect_true(is.factor(v)) expect_equal(levels(v), enums) expect_equal(as.integer(v), c(1:5,5:1)) + +## current domain +uri <- tempfile() +dim <- tiledb_dim("dim", c(1L, 1000L), 50L, type = "INT32") +dom <- tiledb_domain(dim = dim) +attr <- tiledb_attr("a", type = "INT32") +sch <- tiledb_array_schema(dom, attrs = attr, sparse = TRUE) +arr <- tiledb_array_create(uri, sch) +cd <- tiledb_current_domain() +ndr <- tiledb_ndrectangle(dom) +tiledb_ndrectangle_set_range(ndr, "dim", 1L, 100L) +cd <- tiledb_current_domain_set_ndrectangle(cd, ndr) +ase <- tiledb_array_schema_evolution() +expect_silent(tiledb_array_schema_evolution_expand_current_domain(ase, cd)) +expect_silent(tiledb_array_schema_evolution_array_evolve(ase, uri)) diff --git a/inst/tinytest/test_currentdomain.R b/inst/tinytest/test_currentdomain.R index 3fdae1030a..bd5d8002b2 100644 --- a/inst/tinytest/test_currentdomain.R +++ b/inst/tinytest/test_currentdomain.R @@ -19,3 +19,50 @@ expect_silent(newndr <- tiledb_current_domain_get_ndrectangle(cd)) expect_silent(newtp <- tiledb_current_domain_get_type(cd)) expect_true(is(newndr, "tiledb_ndrectangle")) expect_equal(tiledb_ndrectangle_get_range(newndr, "dim"), c(41L, 42L)) + +## complete example with multiple dims and schema evolution +uri <- tempfile() +dim <- c(tiledb_dim("row", c(1L, 1000L), 50L, type = "INT32"), + tiledb_dim("col", c(1L, 100000L), 500L, type = "INT64"), + tiledb_dim("key", c(NULL, NULL), NULL, type = "ASCII")) +dom <- tiledb_domain(dim = dim) +attr <- tiledb_attr("a", type = "INT32") # unused +sch <- tiledb_array_schema(dom, attrs = attr, sparse = TRUE) +arr <- tiledb_array_create(uri, sch) +expandDomain <- function(uri, upperend=200L, upperkey="dd") { + ase <- tiledb_array_schema_evolution() + sch <- tiledb::schema(uri) + dom <- tiledb::domain(sch) + cd <- tiledb_current_domain() + ndr <- tiledb_ndrectangle(dom) + tiledb_ndrectangle_set_range(ndr, "row", 1L, upperend) + tiledb_ndrectangle_set_range(ndr, "col", bit64::as.integer64(1L), bit64::as.integer64(10 * upperend)) + tiledb_ndrectangle_set_range(ndr, "key", "bb", upperkey) + tiledb_current_domain_set_ndrectangle(cd, ndr) + tiledb_array_schema_evolution_expand_current_domain(ase, cd) + tiledb_array_schema_evolution_array_evolve(ase, uri) + invisible(NULL) +} +expect_silent(expandDomain(uri)) +sch <- tiledb::schema(uri) +cd <- tiledb_array_schema_get_current_domain(sch) +ndr <- tiledb_current_domain_get_ndrectangle(cd) +expect_equal(tiledb_ndrectangle_get_range(ndr, "row"), c(1, 200)) +expect_equal(tiledb_ndrectangle_get_range(ndr, "col"), bit64::as.integer64(c(1, 2000))) +expect_equal(tiledb_ndrectangle_get_range(ndr, "key"), c("bb", "dd")) + +expandDomain(uri, 300L, "ff") +sch <- tiledb::schema(uri) +cd <- tiledb_array_schema_get_current_domain(sch) +ndr <- tiledb_current_domain_get_ndrectangle(cd) +expect_equal(tiledb_ndrectangle_get_range(ndr, "row"), c(1, 300)) +expect_equal(tiledb_ndrectangle_get_range(ndr, "col"), bit64::as.integer64(c(1, 3000))) +expect_equal(tiledb_ndrectangle_get_range(ndr, "key"), c("bb", "ff")) + +expandDomain(uri, 400L, "kk") +sch <- tiledb::schema(uri) +cd <- tiledb_array_schema_get_current_domain(sch) +ndr <- tiledb_current_domain_get_ndrectangle(cd) +expect_equal(tiledb_ndrectangle_get_range(ndr, "row"), c(1, 400)) +expect_equal(tiledb_ndrectangle_get_range(ndr, "col"), bit64::as.integer64(c(1, 4000))) +expect_equal(tiledb_ndrectangle_get_range(ndr, "key"), c("bb", "kk")) diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index bbfd0e28c3..29d0baf2e3 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -866,7 +866,7 @@ XPtr libtiledb_dim(XPtr ctx, } else if (dtype == TILEDB_STRING_ASCII) { if (Rf_isNull(domain) && Rf_isNull(tile_extent)) { - auto d = tiledb::Dimension::create(*ctx.get(), name, TILEDB_STRING_ASCII, nullptr, nullptr); + auto d = tiledb::Dimension::create(*ctx.get(), name, dtype, nullptr, nullptr); auto dim = new tiledb::Dimension(d); auto ptr = make_xptr(dim); return ptr; From d80b146e465b43a04c37f73eb87acc4c43c5ae10 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Thu, 25 Jul 2024 13:38:40 -0500 Subject: [PATCH 10/10] Refinments for builds under older TileDB Embedded versions --- R/ArraySchema.R | 4 ++-- R/CurrentDomain.R | 1 - R/NDRectangle.R | 4 ++-- inst/tinytest/test_arrayschema.R | 1 + inst/tinytest/test_arrayschemaevolution.R | 1 + inst/tinytest/test_ndrectangle.R | 2 -- man/tiledb_current_domain-class.Rd | 2 ++ src/libtiledb.cpp | 5 +++++ 8 files changed, 13 insertions(+), 7 deletions(-) diff --git a/R/ArraySchema.R b/R/ArraySchema.R index ca4da5e3fd..9895049f55 100644 --- a/R/ArraySchema.R +++ b/R/ArraySchema.R @@ -918,8 +918,8 @@ tiledb_array_schema_get_current_domain <- function(schema, ctx = tiledb_get_cont stopifnot("Argument 'schema' must be a 'tiledb_array_schema'" = is(schema, "tiledb_array_schema"), "Argument 'ctx' must be a 'tiledb_ctx'" = is(ctx, "tiledb_ctx")) cdptr <- libtiledb_array_schema_get_current_domain(ctx@ptr, schema@ptr) - typestr <- datatype(domain(schema)) - names(typestr) <- sapply(dimensions(domain(schema)), name) + typestr <- tiledb::datatype(tiledb::domain(schema)) + names(typestr) <- sapply(tiledb::dimensions(tiledb::domain(schema)), name) new("tiledb_current_domain", ptr=cdptr, datatype=typestr) } diff --git a/R/CurrentDomain.R b/R/CurrentDomain.R index 203b2520b9..085a7c49ca 100644 --- a/R/CurrentDomain.R +++ b/R/CurrentDomain.R @@ -70,7 +70,6 @@ tiledb_current_domain_set_ndrectangle <- function(cd, ndr) { is(cd, "tiledb_current_domain"), "The second argument must be a TileDB NDRectangle object" = is(ndr, "tiledb_ndrectangle"), "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") - spdl::debug("[tiledb_current_domain_set_ndrectangle] before libtile call") cd@ptr <- libtiledb_current_domain_set_ndrectangle(cd@ptr, ndr@ptr) cd@datatype <- ndr@datatype cd diff --git a/R/NDRectangle.R b/R/NDRectangle.R index 6382795ad5..3592c56608 100644 --- a/R/NDRectangle.R +++ b/R/NDRectangle.R @@ -46,8 +46,8 @@ tiledb_ndrectangle <- function(dom, ctx = tiledb_get_context()) { stopifnot("The first argument must be a TileDB Domain object" = is(dom, "tiledb_domain"), "The second argment must be a TileDB Ctx object" = is(ctx, "tiledb_ctx"), "This function needs TileDB 2.25.0 or later" = tiledb_version(TRUE) >= "2.25.0") - typestr <- datatype(dom) - names(typestr) <- sapply(dimensions(dom), name) + typestr <- tiledb::datatype(dom) + names(typestr) <- sapply(tiledb::dimensions(dom), name) ptr <- libtiledb_ndrectangle_create(ctx@ptr, dom@ptr) return(new("tiledb_ndrectangle", ptr = ptr, datatype = typestr)) } diff --git a/inst/tinytest/test_arrayschema.R b/inst/tinytest/test_arrayschema.R index 50403df1ad..394f1d3dd9 100644 --- a/inst/tinytest/test_arrayschema.R +++ b/inst/tinytest/test_arrayschema.R @@ -143,6 +143,7 @@ expect_true(allows_dups(sch)) ## current domain +if (tiledb_version(TRUE) < "2.25.0") exit_file("Needs TileDB 2.25.* or later") expect_error(tiledb_array_schema_get_current_domain(dom)) # wrong object expect_silent(cd <- tiledb_array_schema_get_current_domain(sch)) expect_silent(tiledb_array_schema_set_current_domain(sch, cd)) diff --git a/inst/tinytest/test_arrayschemaevolution.R b/inst/tinytest/test_arrayschemaevolution.R index f483327f14..08f1e41294 100644 --- a/inst/tinytest/test_arrayschemaevolution.R +++ b/inst/tinytest/test_arrayschemaevolution.R @@ -257,6 +257,7 @@ expect_equal(levels(v), enums) expect_equal(as.integer(v), c(1:5,5:1)) ## current domain +if (tiledb_version(TRUE) < "2.25.0") exit_file("Needs TileDB 2.25.* or later") uri <- tempfile() dim <- tiledb_dim("dim", c(1L, 1000L), 50L, type = "INT32") dom <- tiledb_domain(dim = dim) diff --git a/inst/tinytest/test_ndrectangle.R b/inst/tinytest/test_ndrectangle.R index 528ebf6231..6c80314be9 100644 --- a/inst/tinytest/test_ndrectangle.R +++ b/inst/tinytest/test_ndrectangle.R @@ -42,6 +42,4 @@ expect_error(tiledb_ndrectangle_set_range(ndr, "strdim", 1L, 2)) # wrong type expect_silent(ndr <- tiledb_ndrectangle_set_range(ndr, "strdim", "aa", "zz")) expect_error(tiledb_ndrectangle_set_range(ndr, "notdim")) # wrong name -## for reasons that are unclear this passes under dev aka 2.26.0 but creates CI issues with 2.25.0-rc0 -if (tiledb_version(TRUE) < "2.26.0") exit_file("These tests needs TileDB 2.26.0 or later") expect_equal(tiledb_ndrectangle_get_range(ndr, "strdim"), c("aa", "zz")) diff --git a/man/tiledb_current_domain-class.Rd b/man/tiledb_current_domain-class.Rd index 7d2edfcbf9..9a72458961 100644 --- a/man/tiledb_current_domain-class.Rd +++ b/man/tiledb_current_domain-class.Rd @@ -11,5 +11,7 @@ An S4 class for a TileDB CurrentDomain object \describe{ \item{\code{ptr}}{An external pointer to the underlying CurrentDomain object} + +\item{\code{datatype}}{An character variable describing the data type of the domain} }} diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index 29d0baf2e3..de10947c76 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -471,14 +471,18 @@ tiledb_vfs_mode_t _string_to_tiledb_vfs_mode_t(std::string modestr) { } } +#if TILEDB_VERSION >= TileDB_Version(2,25,0) std::string _tiledb_current_domain_type_to_string(tiledb_current_domain_type_t type) { if (type == TILEDB_NDRECTANGLE) { return std::string{"NDRECTANGLE"}; } else { Rcpp::stop("Unknown TileDB CurrentDomain type (%d)", (int32_t) type); } + return std::string(); } +#endif +#if TILEDB_VERSION >= TileDB_Version(2,25,0) tiledb_current_domain_type_t _string_to_tiledb_current_domain_type(std::string typestr) { if (typestr == "NDRECTANGLE") { return TILEDB_NDRECTANGLE; @@ -486,6 +490,7 @@ tiledb_current_domain_type_t _string_to_tiledb_current_domain_type(std::string t Rcpp::stop("Unknown TileDB CurrentDomain type '%s'", typestr.c_str()); } } +#endif // NB Limited type coverage here as aimed to sizing R allocations of either int, double or char // Also note that there is 'inline size_t type_size(tiledb_datatype_t type)' in core_interface.h