From 16d94ec78f35f043580d6f11f1e99da30e17dcce Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Fri, 20 Aug 2021 20:35:26 -0500 Subject: [PATCH 01/10] fragment info support --- NAMESPACE | 17 ++ R/FragmentInfo.R | 216 +++++++++++++++++ R/RcppExports.R | 68 ++++++ man/tiledb_fragment_info-class.Rd | 15 ++ man/tiledb_fragment_info.Rd | 20 ++ man/tiledb_fragment_info_dense.Rd | 19 ++ man/tiledb_fragment_info_dump.Rd | 17 ++ man/tiledb_fragment_info_get_cell_num.Rd | 19 ++ ...ragment_info_get_non_empty_domain_index.Rd | 28 +++ ...fragment_info_get_non_empty_domain_name.Rd | 28 +++ ...ent_info_get_non_empty_domain_var_index.Rd | 21 ++ ...ment_info_get_non_empty_domain_var_name.Rd | 21 ++ man/tiledb_fragment_info_get_num.Rd | 25 ++ ...iledb_fragment_info_get_timestamp_range.Rd | 19 ++ man/tiledb_fragment_info_get_to_vacuum_uri.Rd | 19 ++ ...nt_info_get_unconsolidated_metadata_num.Rd | 19 ++ man/tiledb_fragment_info_get_version.Rd | 19 ++ ...fragment_info_has_consolidated_metadata.Rd | 19 ++ man/tiledb_fragment_info_sparse.Rd | 19 ++ man/tiledb_fragment_info_uri.Rd | 19 ++ src/RcppExports.cpp | 223 ++++++++++++++++++ src/finalizers.h | 9 + src/libtiledb.cpp | 118 +++++++++ 23 files changed, 997 insertions(+) create mode 100644 R/FragmentInfo.R create mode 100644 man/tiledb_fragment_info-class.Rd create mode 100644 man/tiledb_fragment_info.Rd create mode 100644 man/tiledb_fragment_info_dense.Rd create mode 100644 man/tiledb_fragment_info_dump.Rd create mode 100644 man/tiledb_fragment_info_get_cell_num.Rd create mode 100644 man/tiledb_fragment_info_get_non_empty_domain_index.Rd create mode 100644 man/tiledb_fragment_info_get_non_empty_domain_name.Rd create mode 100644 man/tiledb_fragment_info_get_non_empty_domain_var_index.Rd create mode 100644 man/tiledb_fragment_info_get_non_empty_domain_var_name.Rd create mode 100644 man/tiledb_fragment_info_get_num.Rd create mode 100644 man/tiledb_fragment_info_get_timestamp_range.Rd create mode 100644 man/tiledb_fragment_info_get_to_vacuum_uri.Rd create mode 100644 man/tiledb_fragment_info_get_unconsolidated_metadata_num.Rd create mode 100644 man/tiledb_fragment_info_get_version.Rd create mode 100644 man/tiledb_fragment_info_has_consolidated_metadata.Rd create mode 100644 man/tiledb_fragment_info_sparse.Rd create mode 100644 man/tiledb_fragment_info_uri.Rd diff --git a/NAMESPACE b/NAMESPACE index a6ff275fd2..579bb03e80 100644 --- a/NAMESPACE +++ b/NAMESPACE @@ -111,6 +111,22 @@ export(tiledb_filter_list_get_max_chunk_size) export(tiledb_filter_list_set_max_chunk_size) export(tiledb_filter_set_option) export(tiledb_filter_type) +export(tiledb_fragment_info) +export(tiledb_fragment_info_dense) +export(tiledb_fragment_info_dump) +export(tiledb_fragment_info_get_cell_num) +export(tiledb_fragment_info_get_non_empty_domain_index) +export(tiledb_fragment_info_get_non_empty_domain_name) +export(tiledb_fragment_info_get_non_empty_domain_var_index) +export(tiledb_fragment_info_get_non_empty_domain_var_name) +export(tiledb_fragment_info_get_num) +export(tiledb_fragment_info_get_timestamp_range) +export(tiledb_fragment_info_get_to_vacuum_uri) +export(tiledb_fragment_info_get_unconsolidated_metadata_num) +export(tiledb_fragment_info_get_version) +export(tiledb_fragment_info_has_consolidated_metadata) +export(tiledb_fragment_info_sparse) +export(tiledb_fragment_info_uri) export(tiledb_get_all_metadata) export(tiledb_get_context) export(tiledb_get_metadata) @@ -211,6 +227,7 @@ exportClasses(tiledb_dim) exportClasses(tiledb_domain) exportClasses(tiledb_filter) exportClasses(tiledb_filter_list) +exportClasses(tiledb_fragment_info) exportClasses(tiledb_query) exportClasses(tiledb_query_condition) exportClasses(tiledb_sparse) diff --git a/R/FragmentInfo.R b/R/FragmentInfo.R new file mode 100644 index 0000000000..89b902b3ff --- /dev/null +++ b/R/FragmentInfo.R @@ -0,0 +1,216 @@ +# MIT License +# +# Copyright (c) 2017-2020 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 +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +#' An S4 class for a TileDB fragment info object +#' +#' @slot ptr An external pointer to the underlying implementation +#' @exportClass tiledb_fragment_info +setClass("tiledb_fragment_info", + slots = list(ptr = "externalptr")) + +tiledb_fragment_info.from_ptr <- function(ptr) { + stopifnot(is(ptr, "externalptr")) + return(new("tiledb_fragment_info", ptr = ptr)) +} + +#' Constructs a `tiledb_fragment_info` object +#' +#' @param uri an character variable with the URI of the +#' array for which fragment info is request +#' @param ctx tiledb_ctx object (optional) +#' @return tiledb_fragment_info object +#' @export tiledb_fragment_info +tiledb_fragment_info <- function(uri, ctx = tiledb_get_context()) { + stopifnot(`argument ctx must be a tiledb_ctx object` = is(ctx, "tiledb_ctx"), + `argument uri must be a string scalar` = is.scalar(uri, "character")) + + ptr <- libtiledb_fragment_info(ctx@ptr, uri) + return(new("tiledb_fragment_info", ptr = ptr)) +} + +#' Return a fragment info URI given its index +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @return A character variable with URI +#' @export +tiledb_fragment_info_uri <- function(object, fid) { + libtiledb_fragment_info_uri(object@ptr, fid) +} + +#' Return a fragment info non-empty domain from index +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @param did A domain index +#' @param ctx tiledb_ctx object (optional) +#' @return A TileDB Domain object +#' @export +tiledb_fragment_info_get_non_empty_domain_index <- function(object, fid, did, + ctx = tiledb_get_context()) { + domptr <- libtiledb_fragment_info_get_non_empty_domain_index(object@ptr, fid, did, ctx@ptr) + new("tiledb_domain", ptr = domptr) +} + +#' Return a fragment info non-empty domain from name +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @param dim_name A character variable with the dimension name +#' @param ctx tiledb_ctx object (optional) +#' @return A TileDB Domain object +#' @export +tiledb_fragment_info_get_non_empty_domain_name <- function(object, fid, dim_name, + ctx = tiledb_get_context()) { + domptr <- libtiledb_fragment_info_get_non_empty_domain_name(object@ptr, fid, dim_name, ctx@ptr) + new("tiledb_domain", ptr = domptr) +} + +#' Return a fragment info non-empty domain variable from index +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @param did A domain index +#' @return A character vector with two elements +#' @export +tiledb_fragment_info_get_non_empty_domain_var_index <- function(object, fid, did) { + libtiledb_fragment_info_get_non_empty_domain_var_index(object@ptr, fid, did) +} + +#' Return a fragment info non-empty domain variable from name +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @param dim_name A character variable with the dimension name +#' @return A character vector with two elements +#' @export +tiledb_fragment_info_get_non_empty_domain_var_name <- function(object, fid, dim_name) { + libtiledb_fragment_info_get_non_empty_domain_var_name(object@ptr, fid, dim_name) +} + +#' Return a fragment info number of fragments +#' +#' @param object A TileDB fragment info object +#' @return A numeric variable with the number of fragments +#' @export +tiledb_fragment_info_get_num <- function(object) { + libtiledb_fragment_info_num(object@ptr) +} + +#' Return a fragment info fragment size for a given fragment index +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @return A numeric variable with the number of fragments +#' @export +tiledb_fragment_info_get_num <- function(object, fid) { + libtiledb_fragment_info_size(object@ptr, fid) +} + +#' Return if a fragment info index is dense +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @return A logical value indicating if the fragment is dense +#' @export +tiledb_fragment_info_dense <- function(object, fid) { + libtiledb_fragment_info_dense(object@ptr, fid) +} + +#' Return if a fragment info index is sparse +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @return A logical value indicating if the fragment is sparse +#' @export +tiledb_fragment_info_sparse <- function(object, fid) { + libtiledb_fragment_info_sparse(object@ptr, fid) +} + +#' Return a fragment info timestamp range for a given fragment index +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @return A Datetime vector with two elements for the range +#' @export +tiledb_fragment_info_get_timestamp_range <- function(object, fid) { + libtiledb_fragment_info_timestamp_range(object@ptr, fid) +} + +#' Return a fragment info number of cells for a given fragment index +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @return A numeric value with the number of cells +#' @export +tiledb_fragment_info_get_cell_num <- function(object, fid) { + libtiledb_fragment_info_cell_num(object@ptr, fid) +} + +#' Return a fragment info version for a given fragment index +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @return A integer value value with the version +#' @export +tiledb_fragment_info_get_version <- function(object, fid) { + libtiledb_fragment_info_version(object@ptr, fid) +} + +#' Return if a fragment info index has consolidated metadata +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @return A logical value indicating consolidated metadata +#' @export +tiledb_fragment_info_has_consolidated_metadata <- function(object, fid) { + libtiledb_fragment_info_has_consolidated_metadata(object@ptr, fid) +} + +#' Return fragment info number of unconsolidated metadata +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @return A numeric value with the number of unconsolidated metadata +#' @export +tiledb_fragment_info_get_unconsolidated_metadata_num <- function(object, fid) { + libtiledb_fragment_info_unconsolidated_metadata_num(object@ptr, fid) +} + +#' Return fragment info URI of the to be vacuumed index +#' +#' @param object A TileDB fragment info object +#' @param fid A fragment object index +#' @return A character variable with the URI of the be vacuumed index +#' @export +tiledb_fragment_info_get_to_vacuum_uri <- function(object, fid) { + libtiledb_fragment_info_to_vaccum_uri(object@ptr, fid) +} + +#' Dump the fragment info to console +#' +#' @param object A TileDB fragment info object +#' @return Nothing is returned, as a side effect the fragment info is displayed +#' @export +tiledb_fragment_info_dump <- function(object) { + libtiledb_fragment_info_dump(object@ptr) +} diff --git a/R/RcppExports.R b/R/RcppExports.R index 24733ee648..6d55ddd57a 100644 --- a/R/RcppExports.R +++ b/R/RcppExports.R @@ -825,3 +825,71 @@ libtiledb_stats_raw_get <- function() { .Call(`_tiledb_libtiledb_stats_raw_get`) } +libtiledb_fragment_info <- function(ctx, uri) { + .Call(`_tiledb_libtiledb_fragment_info`, ctx, uri) +} + +libtiledb_fragment_info_uri <- function(fi, fid) { + .Call(`_tiledb_libtiledb_fragment_info_uri`, fi, fid) +} + +libtiledb_fragment_info_get_non_empty_domain_index <- function(fi, fid, did, ctx) { + .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_index`, fi, fid, did, ctx) +} + +libtiledb_fragment_info_get_non_empty_domain_name <- function(fi, fid, dim_name, ctx) { + .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_name`, fi, fid, dim_name, ctx) +} + +libtiledb_fragment_info_get_non_empty_domain_var_index <- function(fi, fid, did) { + .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_index`, fi, fid, did) +} + +libtiledb_fragment_info_get_non_empty_domain_var_name <- function(fi, fid, dim_name) { + .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_name`, fi, fid, dim_name) +} + +libtiledb_fragment_info_num <- function(fi) { + .Call(`_tiledb_libtiledb_fragment_info_num`, fi) +} + +libtiledb_fragment_info_size <- function(fi, fid) { + .Call(`_tiledb_libtiledb_fragment_info_size`, fi, fid) +} + +libtiledb_fragment_info_dense <- function(fi, fid) { + .Call(`_tiledb_libtiledb_fragment_info_dense`, fi, fid) +} + +libtiledb_fragment_info_sparse <- function(fi, fid) { + .Call(`_tiledb_libtiledb_fragment_info_sparse`, fi, fid) +} + +libtiledb_fragment_info_timestamp_range <- function(fi, fid) { + .Call(`_tiledb_libtiledb_fragment_info_timestamp_range`, fi, fid) +} + +libtiledb_fragment_info_cell_num <- function(fi, fid) { + .Call(`_tiledb_libtiledb_fragment_info_cell_num`, fi, fid) +} + +libtiledb_fragment_info_version <- function(fi, fid) { + .Call(`_tiledb_libtiledb_fragment_info_version`, fi, fid) +} + +libtiledb_fragment_info_has_consolidated_metadata <- function(fi, fid) { + .Call(`_tiledb_libtiledb_fragment_info_has_consolidated_metadata`, fi, fid) +} + +libtiledb_fragment_info_unconsolidated_metadata_num <- function(fi) { + .Call(`_tiledb_libtiledb_fragment_info_unconsolidated_metadata_num`, fi) +} + +libtiledb_fragment_info_to_vacuum_uri <- function(fi, fid) { + .Call(`_tiledb_libtiledb_fragment_info_to_vacuum_uri`, fi, fid) +} + +libtiledb_fragment_info_dump <- function(fi) { + invisible(.Call(`_tiledb_libtiledb_fragment_info_dump`, fi)) +} + diff --git a/man/tiledb_fragment_info-class.Rd b/man/tiledb_fragment_info-class.Rd new file mode 100644 index 0000000000..6143cbba2e --- /dev/null +++ b/man/tiledb_fragment_info-class.Rd @@ -0,0 +1,15 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\docType{class} +\name{tiledb_fragment_info-class} +\alias{tiledb_fragment_info-class} +\title{An S4 class for a TileDB fragment info object} +\description{ +An S4 class for a TileDB fragment info object +} +\section{Slots}{ + +\describe{ +\item{\code{ptr}}{An external pointer to the underlying implementation} +}} + diff --git a/man/tiledb_fragment_info.Rd b/man/tiledb_fragment_info.Rd new file mode 100644 index 0000000000..8e15b8149d --- /dev/null +++ b/man/tiledb_fragment_info.Rd @@ -0,0 +1,20 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info} +\alias{tiledb_fragment_info} +\title{Constructs a \code{tiledb_fragment_info} object} +\usage{ +tiledb_fragment_info(uri, ctx = tiledb_get_context()) +} +\arguments{ +\item{uri}{an character variable with the URI of the +array for which fragment info is request} + +\item{ctx}{tiledb_ctx object (optional)} +} +\value{ +tiledb_fragment_info object +} +\description{ +Constructs a \code{tiledb_fragment_info} object +} diff --git a/man/tiledb_fragment_info_dense.Rd b/man/tiledb_fragment_info_dense.Rd new file mode 100644 index 0000000000..6844cfd005 --- /dev/null +++ b/man/tiledb_fragment_info_dense.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_dense} +\alias{tiledb_fragment_info_dense} +\title{Return if a fragment info index is dense} +\usage{ +tiledb_fragment_info_dense(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A logical value indicating if the fragment is dense +} +\description{ +Return if a fragment info index is dense +} diff --git a/man/tiledb_fragment_info_dump.Rd b/man/tiledb_fragment_info_dump.Rd new file mode 100644 index 0000000000..c1325767a1 --- /dev/null +++ b/man/tiledb_fragment_info_dump.Rd @@ -0,0 +1,17 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_dump} +\alias{tiledb_fragment_info_dump} +\title{Dump the fragment info to console} +\usage{ +tiledb_fragment_info_dump(object) +} +\arguments{ +\item{object}{A TileDB fragment info object} +} +\value{ +Nothing is returned, as a side effect the fragment info is displayed +} +\description{ +Dump the fragment info to console +} diff --git a/man/tiledb_fragment_info_get_cell_num.Rd b/man/tiledb_fragment_info_get_cell_num.Rd new file mode 100644 index 0000000000..eaeee616c7 --- /dev/null +++ b/man/tiledb_fragment_info_get_cell_num.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_cell_num} +\alias{tiledb_fragment_info_get_cell_num} +\title{Return a fragment info number of cells for a given fragment index} +\usage{ +tiledb_fragment_info_get_cell_num(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A numeric value with the number of cells +} +\description{ +Return a fragment info number of cells for a given fragment index +} diff --git a/man/tiledb_fragment_info_get_non_empty_domain_index.Rd b/man/tiledb_fragment_info_get_non_empty_domain_index.Rd new file mode 100644 index 0000000000..20c19498c0 --- /dev/null +++ b/man/tiledb_fragment_info_get_non_empty_domain_index.Rd @@ -0,0 +1,28 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_non_empty_domain_index} +\alias{tiledb_fragment_info_get_non_empty_domain_index} +\title{Return a fragment info non-empty domain from index} +\usage{ +tiledb_fragment_info_get_non_empty_domain_index( + object, + fid, + did, + ctx = tiledb_get_context() +) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} + +\item{did}{A domain index} + +\item{ctx}{tiledb_ctx object (optional)} +} +\value{ +A TileDB Domain object +} +\description{ +Return a fragment info non-empty domain from index +} diff --git a/man/tiledb_fragment_info_get_non_empty_domain_name.Rd b/man/tiledb_fragment_info_get_non_empty_domain_name.Rd new file mode 100644 index 0000000000..ec8e56da66 --- /dev/null +++ b/man/tiledb_fragment_info_get_non_empty_domain_name.Rd @@ -0,0 +1,28 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_non_empty_domain_name} +\alias{tiledb_fragment_info_get_non_empty_domain_name} +\title{Return a fragment info non-empty domain from name} +\usage{ +tiledb_fragment_info_get_non_empty_domain_name( + object, + fid, + dim_name, + ctx = tiledb_get_context() +) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} + +\item{dim_name}{A character variable with the dimension name} + +\item{ctx}{tiledb_ctx object (optional)} +} +\value{ +A TileDB Domain object +} +\description{ +Return a fragment info non-empty domain from name +} diff --git a/man/tiledb_fragment_info_get_non_empty_domain_var_index.Rd b/man/tiledb_fragment_info_get_non_empty_domain_var_index.Rd new file mode 100644 index 0000000000..62a323d2cd --- /dev/null +++ b/man/tiledb_fragment_info_get_non_empty_domain_var_index.Rd @@ -0,0 +1,21 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_non_empty_domain_var_index} +\alias{tiledb_fragment_info_get_non_empty_domain_var_index} +\title{Return a fragment info non-empty domain variable from index} +\usage{ +tiledb_fragment_info_get_non_empty_domain_var_index(object, fid, did) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} + +\item{did}{A domain index} +} +\value{ +A character vector with two elements +} +\description{ +Return a fragment info non-empty domain variable from index +} diff --git a/man/tiledb_fragment_info_get_non_empty_domain_var_name.Rd b/man/tiledb_fragment_info_get_non_empty_domain_var_name.Rd new file mode 100644 index 0000000000..914097abc4 --- /dev/null +++ b/man/tiledb_fragment_info_get_non_empty_domain_var_name.Rd @@ -0,0 +1,21 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_non_empty_domain_var_name} +\alias{tiledb_fragment_info_get_non_empty_domain_var_name} +\title{Return a fragment info non-empty domain variable from name} +\usage{ +tiledb_fragment_info_get_non_empty_domain_var_name(object, fid, dim_name) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} + +\item{dim_name}{A character variable with the dimension name} +} +\value{ +A character vector with two elements +} +\description{ +Return a fragment info non-empty domain variable from name +} diff --git a/man/tiledb_fragment_info_get_num.Rd b/man/tiledb_fragment_info_get_num.Rd new file mode 100644 index 0000000000..5087ac10b5 --- /dev/null +++ b/man/tiledb_fragment_info_get_num.Rd @@ -0,0 +1,25 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_num} +\alias{tiledb_fragment_info_get_num} +\title{Return a fragment info number of fragments} +\usage{ +tiledb_fragment_info_get_num(object, fid) + +tiledb_fragment_info_get_num(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A numeric variable with the number of fragments + +A numeric variable with the number of fragments +} +\description{ +Return a fragment info number of fragments + +Return a fragment info fragment size for a given fragment index +} diff --git a/man/tiledb_fragment_info_get_timestamp_range.Rd b/man/tiledb_fragment_info_get_timestamp_range.Rd new file mode 100644 index 0000000000..9cdb10d0ea --- /dev/null +++ b/man/tiledb_fragment_info_get_timestamp_range.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_timestamp_range} +\alias{tiledb_fragment_info_get_timestamp_range} +\title{Return a fragment info timestamp range for a given fragment index} +\usage{ +tiledb_fragment_info_get_timestamp_range(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A Datetime vector with two elements for the range +} +\description{ +Return a fragment info timestamp range for a given fragment index +} diff --git a/man/tiledb_fragment_info_get_to_vacuum_uri.Rd b/man/tiledb_fragment_info_get_to_vacuum_uri.Rd new file mode 100644 index 0000000000..b62911257f --- /dev/null +++ b/man/tiledb_fragment_info_get_to_vacuum_uri.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_to_vacuum_uri} +\alias{tiledb_fragment_info_get_to_vacuum_uri} +\title{Return fragment info URI of the to be vacuumed index} +\usage{ +tiledb_fragment_info_get_to_vacuum_uri(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A character variable with the URI of the be vacuumed index +} +\description{ +Return fragment info URI of the to be vacuumed index +} diff --git a/man/tiledb_fragment_info_get_unconsolidated_metadata_num.Rd b/man/tiledb_fragment_info_get_unconsolidated_metadata_num.Rd new file mode 100644 index 0000000000..60aae17214 --- /dev/null +++ b/man/tiledb_fragment_info_get_unconsolidated_metadata_num.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_unconsolidated_metadata_num} +\alias{tiledb_fragment_info_get_unconsolidated_metadata_num} +\title{Return fragment info number of unconsolidated metadata} +\usage{ +tiledb_fragment_info_get_unconsolidated_metadata_num(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A numeric value with the number of unconsolidated metadata +} +\description{ +Return fragment info number of unconsolidated metadata +} diff --git a/man/tiledb_fragment_info_get_version.Rd b/man/tiledb_fragment_info_get_version.Rd new file mode 100644 index 0000000000..f431e8736c --- /dev/null +++ b/man/tiledb_fragment_info_get_version.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_version} +\alias{tiledb_fragment_info_get_version} +\title{Return a fragment info version for a given fragment index} +\usage{ +tiledb_fragment_info_get_version(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A integer value value with the version +} +\description{ +Return a fragment info version for a given fragment index +} diff --git a/man/tiledb_fragment_info_has_consolidated_metadata.Rd b/man/tiledb_fragment_info_has_consolidated_metadata.Rd new file mode 100644 index 0000000000..c358dc446f --- /dev/null +++ b/man/tiledb_fragment_info_has_consolidated_metadata.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_has_consolidated_metadata} +\alias{tiledb_fragment_info_has_consolidated_metadata} +\title{Return if a fragment info index has consolidated metadata} +\usage{ +tiledb_fragment_info_has_consolidated_metadata(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A logical value indicating consolidated metadata +} +\description{ +Return if a fragment info index has consolidated metadata +} diff --git a/man/tiledb_fragment_info_sparse.Rd b/man/tiledb_fragment_info_sparse.Rd new file mode 100644 index 0000000000..f48889c74e --- /dev/null +++ b/man/tiledb_fragment_info_sparse.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_sparse} +\alias{tiledb_fragment_info_sparse} +\title{Return if a fragment info index is sparse} +\usage{ +tiledb_fragment_info_sparse(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A logical value indicating if the fragment is sparse +} +\description{ +Return if a fragment info index is sparse +} diff --git a/man/tiledb_fragment_info_uri.Rd b/man/tiledb_fragment_info_uri.Rd new file mode 100644 index 0000000000..1abf800870 --- /dev/null +++ b/man/tiledb_fragment_info_uri.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_uri} +\alias{tiledb_fragment_info_uri} +\title{Return a fragment info URI given its index} +\usage{ +tiledb_fragment_info_uri(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A character variable with URI +} +\description{ +Return a fragment info URI given its index +} diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp index 57bb9eb0d9..2c5ed9e361 100644 --- a/src/RcppExports.cpp +++ b/src/RcppExports.cpp @@ -2457,6 +2457,212 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// libtiledb_fragment_info +XPtr libtiledb_fragment_info(XPtr ctx, const std::string& uri); +RcppExport SEXP _tiledb_libtiledb_fragment_info(SEXP ctxSEXP, SEXP uriSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type ctx(ctxSEXP); + Rcpp::traits::input_parameter< const std::string& >::type uri(uriSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info(ctx, uri)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_uri +std::string libtiledb_fragment_info_uri(XPtr fi, int32_t fid); +RcppExport SEXP _tiledb_libtiledb_fragment_info_uri(SEXP fiSEXP, SEXP fidSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_uri(fi, fid)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_get_non_empty_domain_index +XPtr libtiledb_fragment_info_get_non_empty_domain_index(XPtr fi, int32_t fid, int32_t did, XPtr ctx); +RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_index(SEXP fiSEXP, SEXP fidSEXP, SEXP didSEXP, SEXP ctxSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + Rcpp::traits::input_parameter< int32_t >::type did(didSEXP); + Rcpp::traits::input_parameter< XPtr >::type ctx(ctxSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_index(fi, fid, did, ctx)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_get_non_empty_domain_name +XPtr libtiledb_fragment_info_get_non_empty_domain_name(XPtr fi, int32_t fid, const std::string& dim_name, XPtr ctx); +RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_name(SEXP fiSEXP, SEXP fidSEXP, SEXP dim_nameSEXP, SEXP ctxSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + Rcpp::traits::input_parameter< const std::string& >::type dim_name(dim_nameSEXP); + Rcpp::traits::input_parameter< XPtr >::type ctx(ctxSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_name(fi, fid, dim_name, ctx)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_get_non_empty_domain_var_index +Rcpp::CharacterVector libtiledb_fragment_info_get_non_empty_domain_var_index(XPtr fi, int32_t fid, int32_t did); +RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_var_index(SEXP fiSEXP, SEXP fidSEXP, SEXP didSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + Rcpp::traits::input_parameter< int32_t >::type did(didSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_var_index(fi, fid, did)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_get_non_empty_domain_var_name +Rcpp::CharacterVector libtiledb_fragment_info_get_non_empty_domain_var_name(XPtr fi, int32_t fid, const std::string& dim_name); +RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_var_name(SEXP fiSEXP, SEXP fidSEXP, SEXP dim_nameSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + Rcpp::traits::input_parameter< const std::string& >::type dim_name(dim_nameSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_var_name(fi, fid, dim_name)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_num +double libtiledb_fragment_info_num(XPtr fi); +RcppExport SEXP _tiledb_libtiledb_fragment_info_num(SEXP fiSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_num(fi)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_size +double libtiledb_fragment_info_size(XPtr fi, int32_t fid); +RcppExport SEXP _tiledb_libtiledb_fragment_info_size(SEXP fiSEXP, SEXP fidSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_size(fi, fid)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_dense +bool libtiledb_fragment_info_dense(XPtr fi, int32_t fid); +RcppExport SEXP _tiledb_libtiledb_fragment_info_dense(SEXP fiSEXP, SEXP fidSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_dense(fi, fid)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_sparse +bool libtiledb_fragment_info_sparse(XPtr fi, int32_t fid); +RcppExport SEXP _tiledb_libtiledb_fragment_info_sparse(SEXP fiSEXP, SEXP fidSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_sparse(fi, fid)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_timestamp_range +Rcpp::DatetimeVector libtiledb_fragment_info_timestamp_range(XPtr fi, int32_t fid); +RcppExport SEXP _tiledb_libtiledb_fragment_info_timestamp_range(SEXP fiSEXP, SEXP fidSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_timestamp_range(fi, fid)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_cell_num +double libtiledb_fragment_info_cell_num(XPtr fi, int32_t fid); +RcppExport SEXP _tiledb_libtiledb_fragment_info_cell_num(SEXP fiSEXP, SEXP fidSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_cell_num(fi, fid)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_version +int libtiledb_fragment_info_version(XPtr fi, int32_t fid); +RcppExport SEXP _tiledb_libtiledb_fragment_info_version(SEXP fiSEXP, SEXP fidSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_version(fi, fid)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_has_consolidated_metadata +bool libtiledb_fragment_info_has_consolidated_metadata(XPtr fi, int32_t fid); +RcppExport SEXP _tiledb_libtiledb_fragment_info_has_consolidated_metadata(SEXP fiSEXP, SEXP fidSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_has_consolidated_metadata(fi, fid)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_unconsolidated_metadata_num +double libtiledb_fragment_info_unconsolidated_metadata_num(XPtr fi); +RcppExport SEXP _tiledb_libtiledb_fragment_info_unconsolidated_metadata_num(SEXP fiSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_unconsolidated_metadata_num(fi)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_to_vacuum_uri +std::string libtiledb_fragment_info_to_vacuum_uri(XPtr fi, int32_t fid); +RcppExport SEXP _tiledb_libtiledb_fragment_info_to_vacuum_uri(SEXP fiSEXP, SEXP fidSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_to_vacuum_uri(fi, fid)); + return rcpp_result_gen; +END_RCPP +} +// libtiledb_fragment_info_dump +void libtiledb_fragment_info_dump(XPtr fi); +RcppExport SEXP _tiledb_libtiledb_fragment_info_dump(SEXP fiSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + libtiledb_fragment_info_dump(fi); + return R_NilValue; +END_RCPP +} static const R_CallMethodDef CallEntries[] = { {"_tiledb_allocate_arrow_array_as_double", (DL_FUNC) &_tiledb_allocate_arrow_array_as_double, 0}, @@ -2665,6 +2871,23 @@ static const R_CallMethodDef CallEntries[] = { {"_tiledb_libtiledb_stats_dump", (DL_FUNC) &_tiledb_libtiledb_stats_dump, 1}, {"_tiledb_libtiledb_stats_raw_dump", (DL_FUNC) &_tiledb_libtiledb_stats_raw_dump, 1}, {"_tiledb_libtiledb_stats_raw_get", (DL_FUNC) &_tiledb_libtiledb_stats_raw_get, 0}, + {"_tiledb_libtiledb_fragment_info", (DL_FUNC) &_tiledb_libtiledb_fragment_info, 2}, + {"_tiledb_libtiledb_fragment_info_uri", (DL_FUNC) &_tiledb_libtiledb_fragment_info_uri, 2}, + {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_index", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_index, 4}, + {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_name", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_name, 4}, + {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_index", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_index, 3}, + {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_name", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_name, 3}, + {"_tiledb_libtiledb_fragment_info_num", (DL_FUNC) &_tiledb_libtiledb_fragment_info_num, 1}, + {"_tiledb_libtiledb_fragment_info_size", (DL_FUNC) &_tiledb_libtiledb_fragment_info_size, 2}, + {"_tiledb_libtiledb_fragment_info_dense", (DL_FUNC) &_tiledb_libtiledb_fragment_info_dense, 2}, + {"_tiledb_libtiledb_fragment_info_sparse", (DL_FUNC) &_tiledb_libtiledb_fragment_info_sparse, 2}, + {"_tiledb_libtiledb_fragment_info_timestamp_range", (DL_FUNC) &_tiledb_libtiledb_fragment_info_timestamp_range, 2}, + {"_tiledb_libtiledb_fragment_info_cell_num", (DL_FUNC) &_tiledb_libtiledb_fragment_info_cell_num, 2}, + {"_tiledb_libtiledb_fragment_info_version", (DL_FUNC) &_tiledb_libtiledb_fragment_info_version, 2}, + {"_tiledb_libtiledb_fragment_info_has_consolidated_metadata", (DL_FUNC) &_tiledb_libtiledb_fragment_info_has_consolidated_metadata, 2}, + {"_tiledb_libtiledb_fragment_info_unconsolidated_metadata_num", (DL_FUNC) &_tiledb_libtiledb_fragment_info_unconsolidated_metadata_num, 1}, + {"_tiledb_libtiledb_fragment_info_to_vacuum_uri", (DL_FUNC) &_tiledb_libtiledb_fragment_info_to_vacuum_uri, 2}, + {"_tiledb_libtiledb_fragment_info_dump", (DL_FUNC) &_tiledb_libtiledb_fragment_info_dump, 1}, {NULL, NULL, 0} }; diff --git a/src/finalizers.h b/src/finalizers.h index 8fa259d688..94cd48e8e0 100644 --- a/src/finalizers.h +++ b/src/finalizers.h @@ -171,6 +171,15 @@ extern "C" { } } + inline void libtiledb_fragment_info_delete(SEXP sexp) { + XPtr fi(sexp); + tiledb::FragmentInfo* ptr = fi.get(); + if (ptr != nullptr) { + delete ptr; + ptr = nullptr; + } + } + } #endif diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index 0ad66b98ab..4b832b8056 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -3726,3 +3726,121 @@ std::string libtiledb_stats_raw_get() { return result; #endif } + +/** + * FragmentInfo + */ +// [[Rcpp::export]] +XPtr libtiledb_fragment_info(XPtr ctx, + const std::string& uri) { + auto ptr = XPtr(new tiledb::FragmentInfo(*ctx.get(), uri)); + registerXptrFinalizer(ptr, libtiledb_fragment_info_delete); + ptr->load(); // also load + return ptr; +} + +// [[Rcpp::export]] +std::string libtiledb_fragment_info_uri(XPtr fi, int32_t fid) { + return fi->fragment_uri(static_cast(fid)); +} + +// [[Rcpp::export]] +XPtr libtiledb_fragment_info_get_non_empty_domain_index(XPtr fi, + int32_t fid, int32_t did, + XPtr ctx) { + + XPtr domain = XPtr(new tiledb::Domain(*ctx.get())); + fi->get_non_empty_domain(static_cast(fid), + static_cast(did), + static_cast(domain.get())); + //libtiledb_domain_dump(domain); + //registerXptrFinalizer(domain, libtiledb_domain_delete); + return domain; +} + +// [[Rcpp::export]] +XPtr libtiledb_fragment_info_get_non_empty_domain_name(XPtr fi, + int32_t fid, + const std::string& dim_name, + XPtr ctx) { + auto domptr = new tiledb::Domain(*ctx.get()); + fi->get_non_empty_domain(static_cast(fid), dim_name, + static_cast(domptr)); + XPtr domain(domptr, false); + registerXptrFinalizer(domain, libtiledb_domain_delete); + return domain; +} + +// [[Rcpp::export]] +Rcpp::CharacterVector +libtiledb_fragment_info_get_non_empty_domain_var_index(XPtr fi, + int32_t fid, int32_t did) { + auto sp = fi->non_empty_domain_var(static_cast(fid), static_cast(did)); + return CharacterVector::create(sp.first, sp.second); +} + +// [[Rcpp::export]] +Rcpp::CharacterVector +libtiledb_fragment_info_get_non_empty_domain_var_name(XPtr fi, + int32_t fid, + const std::string& dim_name) { + auto sp = fi->non_empty_domain_var(static_cast(fid), dim_name); + return CharacterVector::create(sp.first, sp.second); +} + +// [[Rcpp::export]] +double libtiledb_fragment_info_num(XPtr fi) { + return static_cast(fi->fragment_num()); +} + +// [[Rcpp::export]] +double libtiledb_fragment_info_size(XPtr fi, int32_t fid) { + return static_cast(fi->fragment_size(static_cast(fid))); +} + +// [[Rcpp::export]] +bool libtiledb_fragment_info_dense(XPtr fi, int32_t fid) { + return fi->dense(static_cast(fid)); +} + +// [[Rcpp::export]] +bool libtiledb_fragment_info_sparse(XPtr fi, int32_t fid) { + return fi->sparse(static_cast(fid)); +} + +// [[Rcpp::export]] +Rcpp::DatetimeVector +libtiledb_fragment_info_timestamp_range(XPtr fi, int32_t fid) { + auto range = fi->timestamp_range(static_cast(fid)); + return Rcpp::DatetimeVector::create(range.first/1000.0, range.second/1000.0); +} + +// [[Rcpp::export]] +double libtiledb_fragment_info_cell_num(XPtr fi, int32_t fid) { + return static_cast(fi->cell_num(static_cast(fid))); +} + +// [[Rcpp::export]] +int libtiledb_fragment_info_version(XPtr fi, int32_t fid) { + return static_cast(fi->version(static_cast(fid))); +} + +// [[Rcpp::export]] +bool libtiledb_fragment_info_has_consolidated_metadata(XPtr fi, int32_t fid) { + return fi->has_consolidated_metadata(static_cast(fid)); +} + +// [[Rcpp::export]] +double libtiledb_fragment_info_unconsolidated_metadata_num(XPtr fi) { + return static_cast(fi->unconsolidated_metadata_num()); +} + +// [[Rcpp::export]] +std::string libtiledb_fragment_info_to_vacuum_uri(XPtr fi, int32_t fid) { + return fi->to_vacuum_uri(static_cast(fid)); +} + +// [[Rcpp::export]] +void libtiledb_fragment_info_dump(XPtr fi) { + return fi->dump(); +} From 5e3d92db62a1b3444c9e8d11336b2eeb067c2d30 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Fri, 20 Aug 2021 21:58:38 -0500 Subject: [PATCH 02/10] added note re non_empty_domain getters --- R/FragmentInfo.R | 18 ++++----- R/RcppExports.R | 8 ++-- ...ragment_info_get_non_empty_domain_index.Rd | 11 +----- ...fragment_info_get_non_empty_domain_name.Rd | 11 +----- src/RcppExports.cpp | 18 ++++----- src/libtiledb.cpp | 39 +++++++------------ 6 files changed, 39 insertions(+), 66 deletions(-) diff --git a/R/FragmentInfo.R b/R/FragmentInfo.R index 89b902b3ff..b882333080 100644 --- a/R/FragmentInfo.R +++ b/R/FragmentInfo.R @@ -59,30 +59,28 @@ tiledb_fragment_info_uri <- function(object, fid) { #' Return a fragment info non-empty domain from index #' +#' TODO: Rework with type information +#' #' @param object A TileDB fragment info object #' @param fid A fragment object index #' @param did A domain index -#' @param ctx tiledb_ctx object (optional) #' @return A TileDB Domain object #' @export -tiledb_fragment_info_get_non_empty_domain_index <- function(object, fid, did, - ctx = tiledb_get_context()) { - domptr <- libtiledb_fragment_info_get_non_empty_domain_index(object@ptr, fid, did, ctx@ptr) - new("tiledb_domain", ptr = domptr) +tiledb_fragment_info_get_non_empty_domain_index <- function(object, fid, did) { + libtiledb_fragment_info_get_non_empty_domain_index(object@ptr, fid, did) } #' Return a fragment info non-empty domain from name #' +#' TODO: Rework with type information +#' #' @param object A TileDB fragment info object #' @param fid A fragment object index #' @param dim_name A character variable with the dimension name -#' @param ctx tiledb_ctx object (optional) #' @return A TileDB Domain object #' @export -tiledb_fragment_info_get_non_empty_domain_name <- function(object, fid, dim_name, - ctx = tiledb_get_context()) { - domptr <- libtiledb_fragment_info_get_non_empty_domain_name(object@ptr, fid, dim_name, ctx@ptr) - new("tiledb_domain", ptr = domptr) +tiledb_fragment_info_get_non_empty_domain_name <- function(object, fid, dim_name) { + libtiledb_fragment_info_get_non_empty_domain_name(object@ptr, fid, dim_name) } #' Return a fragment info non-empty domain variable from index diff --git a/R/RcppExports.R b/R/RcppExports.R index 6d55ddd57a..c56824fdd1 100644 --- a/R/RcppExports.R +++ b/R/RcppExports.R @@ -833,12 +833,12 @@ libtiledb_fragment_info_uri <- function(fi, fid) { .Call(`_tiledb_libtiledb_fragment_info_uri`, fi, fid) } -libtiledb_fragment_info_get_non_empty_domain_index <- function(fi, fid, did, ctx) { - .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_index`, fi, fid, did, ctx) +libtiledb_fragment_info_get_non_empty_domain_index <- function(fi, fid, did) { + .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_index`, fi, fid, did) } -libtiledb_fragment_info_get_non_empty_domain_name <- function(fi, fid, dim_name, ctx) { - .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_name`, fi, fid, dim_name, ctx) +libtiledb_fragment_info_get_non_empty_domain_name <- function(fi, fid, dim_name) { + .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_name`, fi, fid, dim_name) } libtiledb_fragment_info_get_non_empty_domain_var_index <- function(fi, fid, did) { diff --git a/man/tiledb_fragment_info_get_non_empty_domain_index.Rd b/man/tiledb_fragment_info_get_non_empty_domain_index.Rd index 20c19498c0..8fe1ba0cdc 100644 --- a/man/tiledb_fragment_info_get_non_empty_domain_index.Rd +++ b/man/tiledb_fragment_info_get_non_empty_domain_index.Rd @@ -4,12 +4,7 @@ \alias{tiledb_fragment_info_get_non_empty_domain_index} \title{Return a fragment info non-empty domain from index} \usage{ -tiledb_fragment_info_get_non_empty_domain_index( - object, - fid, - did, - ctx = tiledb_get_context() -) +tiledb_fragment_info_get_non_empty_domain_index(object, fid, did) } \arguments{ \item{object}{A TileDB fragment info object} @@ -17,12 +12,10 @@ tiledb_fragment_info_get_non_empty_domain_index( \item{fid}{A fragment object index} \item{did}{A domain index} - -\item{ctx}{tiledb_ctx object (optional)} } \value{ A TileDB Domain object } \description{ -Return a fragment info non-empty domain from index +TODO: Rework with type information } diff --git a/man/tiledb_fragment_info_get_non_empty_domain_name.Rd b/man/tiledb_fragment_info_get_non_empty_domain_name.Rd index ec8e56da66..a2c8124e7c 100644 --- a/man/tiledb_fragment_info_get_non_empty_domain_name.Rd +++ b/man/tiledb_fragment_info_get_non_empty_domain_name.Rd @@ -4,12 +4,7 @@ \alias{tiledb_fragment_info_get_non_empty_domain_name} \title{Return a fragment info non-empty domain from name} \usage{ -tiledb_fragment_info_get_non_empty_domain_name( - object, - fid, - dim_name, - ctx = tiledb_get_context() -) +tiledb_fragment_info_get_non_empty_domain_name(object, fid, dim_name) } \arguments{ \item{object}{A TileDB fragment info object} @@ -17,12 +12,10 @@ tiledb_fragment_info_get_non_empty_domain_name( \item{fid}{A fragment object index} \item{dim_name}{A character variable with the dimension name} - -\item{ctx}{tiledb_ctx object (optional)} } \value{ A TileDB Domain object } \description{ -Return a fragment info non-empty domain from name +TODO: Rework with type information } diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp index 2c5ed9e361..0d5a0429b1 100644 --- a/src/RcppExports.cpp +++ b/src/RcppExports.cpp @@ -2482,30 +2482,28 @@ BEGIN_RCPP END_RCPP } // libtiledb_fragment_info_get_non_empty_domain_index -XPtr libtiledb_fragment_info_get_non_empty_domain_index(XPtr fi, int32_t fid, int32_t did, XPtr ctx); -RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_index(SEXP fiSEXP, SEXP fidSEXP, SEXP didSEXP, SEXP ctxSEXP) { +Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_index(XPtr fi, int32_t fid, int32_t did); +RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_index(SEXP fiSEXP, SEXP fidSEXP, SEXP didSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); Rcpp::traits::input_parameter< int32_t >::type did(didSEXP); - Rcpp::traits::input_parameter< XPtr >::type ctx(ctxSEXP); - rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_index(fi, fid, did, ctx)); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_index(fi, fid, did)); return rcpp_result_gen; END_RCPP } // libtiledb_fragment_info_get_non_empty_domain_name -XPtr libtiledb_fragment_info_get_non_empty_domain_name(XPtr fi, int32_t fid, const std::string& dim_name, XPtr ctx); -RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_name(SEXP fiSEXP, SEXP fidSEXP, SEXP dim_nameSEXP, SEXP ctxSEXP) { +Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_name(XPtr fi, int32_t fid, const std::string& dim_name); +RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_name(SEXP fiSEXP, SEXP fidSEXP, SEXP dim_nameSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); Rcpp::traits::input_parameter< const std::string& >::type dim_name(dim_nameSEXP); - Rcpp::traits::input_parameter< XPtr >::type ctx(ctxSEXP); - rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_name(fi, fid, dim_name, ctx)); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_name(fi, fid, dim_name)); return rcpp_result_gen; END_RCPP } @@ -2873,8 +2871,8 @@ static const R_CallMethodDef CallEntries[] = { {"_tiledb_libtiledb_stats_raw_get", (DL_FUNC) &_tiledb_libtiledb_stats_raw_get, 0}, {"_tiledb_libtiledb_fragment_info", (DL_FUNC) &_tiledb_libtiledb_fragment_info, 2}, {"_tiledb_libtiledb_fragment_info_uri", (DL_FUNC) &_tiledb_libtiledb_fragment_info_uri, 2}, - {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_index", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_index, 4}, - {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_name", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_name, 4}, + {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_index", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_index, 3}, + {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_name", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_name, 3}, {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_index", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_index, 3}, {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_name", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_name, 3}, {"_tiledb_libtiledb_fragment_info_num", (DL_FUNC) &_tiledb_libtiledb_fragment_info_num, 1}, diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index 4b832b8056..a06471ccda 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -3745,30 +3745,21 @@ std::string libtiledb_fragment_info_uri(XPtr fi, int32_t f } // [[Rcpp::export]] -XPtr libtiledb_fragment_info_get_non_empty_domain_index(XPtr fi, - int32_t fid, int32_t did, - XPtr ctx) { - - XPtr domain = XPtr(new tiledb::Domain(*ctx.get())); - fi->get_non_empty_domain(static_cast(fid), - static_cast(did), - static_cast(domain.get())); - //libtiledb_domain_dump(domain); - //registerXptrFinalizer(domain, libtiledb_domain_delete); - return domain; -} - -// [[Rcpp::export]] -XPtr libtiledb_fragment_info_get_non_empty_domain_name(XPtr fi, - int32_t fid, - const std::string& dim_name, - XPtr ctx) { - auto domptr = new tiledb::Domain(*ctx.get()); - fi->get_non_empty_domain(static_cast(fid), dim_name, - static_cast(domptr)); - XPtr domain(domptr, false); - registerXptrFinalizer(domain, libtiledb_domain_delete); - return domain; +Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_index(XPtr fi, + int32_t fid, int32_t did) { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + //std::cout << (int32_t) non_empty_dom[0] << " " << (int32_t) non_empty_dom[1] << std::endl; + return makeInteger64(non_empty_dom); +} + +// [[Rcpp::export]] +Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_name(XPtr fi, + int32_t fid, + const std::string& dim_name) { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return makeInteger64(non_empty_dom); } // [[Rcpp::export]] From 2d4f910a4c69f5f55756f64284671a2d974dfa8f Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Sat, 21 Aug 2021 09:43:38 -0500 Subject: [PATCH 03/10] non_empty_dim request now use a type string argument --- R/FragmentInfo.R | 10 +- R/RcppExports.R | 8 +- ...ragment_info_get_non_empty_domain_index.Rd | 4 +- ...fragment_info_get_non_empty_domain_name.Rd | 4 +- src/RcppExports.cpp | 18 ++- src/libtiledb.cpp | 151 ++++++++++++++++-- 6 files changed, 168 insertions(+), 27 deletions(-) diff --git a/R/FragmentInfo.R b/R/FragmentInfo.R index b882333080..da1be63489 100644 --- a/R/FragmentInfo.R +++ b/R/FragmentInfo.R @@ -64,10 +64,11 @@ tiledb_fragment_info_uri <- function(object, fid) { #' @param object A TileDB fragment info object #' @param fid A fragment object index #' @param did A domain index +#' @param typestr A character variable describing the data type #' @return A TileDB Domain object #' @export -tiledb_fragment_info_get_non_empty_domain_index <- function(object, fid, did) { - libtiledb_fragment_info_get_non_empty_domain_index(object@ptr, fid, did) +tiledb_fragment_info_get_non_empty_domain_index <- function(object, fid, did, typestr) { + libtiledb_fragment_info_get_non_empty_domain_index(object@ptr, fid, did, typestr) } #' Return a fragment info non-empty domain from name @@ -77,10 +78,11 @@ tiledb_fragment_info_get_non_empty_domain_index <- function(object, fid, did) { #' @param object A TileDB fragment info object #' @param fid A fragment object index #' @param dim_name A character variable with the dimension name +#' @param typestr A character variable describing the data type #' @return A TileDB Domain object #' @export -tiledb_fragment_info_get_non_empty_domain_name <- function(object, fid, dim_name) { - libtiledb_fragment_info_get_non_empty_domain_name(object@ptr, fid, dim_name) +tiledb_fragment_info_get_non_empty_domain_name <- function(object, fid, dim_name, typestr) { + libtiledb_fragment_info_get_non_empty_domain_name(object@ptr, fid, dim_name, typestr) } #' Return a fragment info non-empty domain variable from index diff --git a/R/RcppExports.R b/R/RcppExports.R index c56824fdd1..c4d3febc7e 100644 --- a/R/RcppExports.R +++ b/R/RcppExports.R @@ -833,12 +833,12 @@ libtiledb_fragment_info_uri <- function(fi, fid) { .Call(`_tiledb_libtiledb_fragment_info_uri`, fi, fid) } -libtiledb_fragment_info_get_non_empty_domain_index <- function(fi, fid, did) { - .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_index`, fi, fid, did) +libtiledb_fragment_info_get_non_empty_domain_index <- function(fi, fid, did, typestr) { + .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_index`, fi, fid, did, typestr) } -libtiledb_fragment_info_get_non_empty_domain_name <- function(fi, fid, dim_name) { - .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_name`, fi, fid, dim_name) +libtiledb_fragment_info_get_non_empty_domain_name <- function(fi, fid, dim_name, typestr) { + .Call(`_tiledb_libtiledb_fragment_info_get_non_empty_domain_name`, fi, fid, dim_name, typestr) } libtiledb_fragment_info_get_non_empty_domain_var_index <- function(fi, fid, did) { diff --git a/man/tiledb_fragment_info_get_non_empty_domain_index.Rd b/man/tiledb_fragment_info_get_non_empty_domain_index.Rd index 8fe1ba0cdc..6b9e34273e 100644 --- a/man/tiledb_fragment_info_get_non_empty_domain_index.Rd +++ b/man/tiledb_fragment_info_get_non_empty_domain_index.Rd @@ -4,7 +4,7 @@ \alias{tiledb_fragment_info_get_non_empty_domain_index} \title{Return a fragment info non-empty domain from index} \usage{ -tiledb_fragment_info_get_non_empty_domain_index(object, fid, did) +tiledb_fragment_info_get_non_empty_domain_index(object, fid, did, typestr) } \arguments{ \item{object}{A TileDB fragment info object} @@ -12,6 +12,8 @@ tiledb_fragment_info_get_non_empty_domain_index(object, fid, did) \item{fid}{A fragment object index} \item{did}{A domain index} + +\item{typestr}{A character variable describing the data type} } \value{ A TileDB Domain object diff --git a/man/tiledb_fragment_info_get_non_empty_domain_name.Rd b/man/tiledb_fragment_info_get_non_empty_domain_name.Rd index a2c8124e7c..7b4bbe1530 100644 --- a/man/tiledb_fragment_info_get_non_empty_domain_name.Rd +++ b/man/tiledb_fragment_info_get_non_empty_domain_name.Rd @@ -4,7 +4,7 @@ \alias{tiledb_fragment_info_get_non_empty_domain_name} \title{Return a fragment info non-empty domain from name} \usage{ -tiledb_fragment_info_get_non_empty_domain_name(object, fid, dim_name) +tiledb_fragment_info_get_non_empty_domain_name(object, fid, dim_name, typestr) } \arguments{ \item{object}{A TileDB fragment info object} @@ -12,6 +12,8 @@ tiledb_fragment_info_get_non_empty_domain_name(object, fid, dim_name) \item{fid}{A fragment object index} \item{dim_name}{A character variable with the dimension name} + +\item{typestr}{A character variable describing the data type} } \value{ A TileDB Domain object diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp index 0d5a0429b1..dc3c49c6c4 100644 --- a/src/RcppExports.cpp +++ b/src/RcppExports.cpp @@ -2482,28 +2482,30 @@ BEGIN_RCPP END_RCPP } // libtiledb_fragment_info_get_non_empty_domain_index -Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_index(XPtr fi, int32_t fid, int32_t did); -RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_index(SEXP fiSEXP, SEXP fidSEXP, SEXP didSEXP) { +Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_index(XPtr fi, int32_t fid, int32_t did, const std::string& typestr); +RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_index(SEXP fiSEXP, SEXP fidSEXP, SEXP didSEXP, SEXP typestrSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); Rcpp::traits::input_parameter< int32_t >::type did(didSEXP); - rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_index(fi, fid, did)); + Rcpp::traits::input_parameter< const std::string& >::type typestr(typestrSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_index(fi, fid, did, typestr)); return rcpp_result_gen; END_RCPP } // libtiledb_fragment_info_get_non_empty_domain_name -Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_name(XPtr fi, int32_t fid, const std::string& dim_name); -RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_name(SEXP fiSEXP, SEXP fidSEXP, SEXP dim_nameSEXP) { +Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_name(XPtr fi, int32_t fid, const std::string& dim_name, const std::string& typestr); +RcppExport SEXP _tiledb_libtiledb_fragment_info_get_non_empty_domain_name(SEXP fiSEXP, SEXP fidSEXP, SEXP dim_nameSEXP, SEXP typestrSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); Rcpp::traits::input_parameter< int32_t >::type fid(fidSEXP); Rcpp::traits::input_parameter< const std::string& >::type dim_name(dim_nameSEXP); - rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_name(fi, fid, dim_name)); + Rcpp::traits::input_parameter< const std::string& >::type typestr(typestrSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_get_non_empty_domain_name(fi, fid, dim_name, typestr)); return rcpp_result_gen; END_RCPP } @@ -2871,8 +2873,8 @@ static const R_CallMethodDef CallEntries[] = { {"_tiledb_libtiledb_stats_raw_get", (DL_FUNC) &_tiledb_libtiledb_stats_raw_get, 0}, {"_tiledb_libtiledb_fragment_info", (DL_FUNC) &_tiledb_libtiledb_fragment_info, 2}, {"_tiledb_libtiledb_fragment_info_uri", (DL_FUNC) &_tiledb_libtiledb_fragment_info_uri, 2}, - {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_index", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_index, 3}, - {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_name", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_name, 3}, + {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_index", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_index, 4}, + {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_name", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_name, 4}, {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_index", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_index, 3}, {"_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_name", (DL_FUNC) &_tiledb_libtiledb_fragment_info_get_non_empty_domain_var_name, 3}, {"_tiledb_libtiledb_fragment_info_num", (DL_FUNC) &_tiledb_libtiledb_fragment_info_num, 1}, diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index a06471ccda..3201cb1b34 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -3746,20 +3746,153 @@ std::string libtiledb_fragment_info_uri(XPtr fi, int32_t f // [[Rcpp::export]] Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_index(XPtr fi, - int32_t fid, int32_t did) { - std::vector non_empty_dom(2); - fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); - //std::cout << (int32_t) non_empty_dom[0] << " " << (int32_t) non_empty_dom[1] << std::endl; - return makeInteger64(non_empty_dom); + int32_t fid, int32_t did, + const std::string& typestr) { +#if TILEDB_VERSION >= TileDB_Version(2,0,0) + if (typestr == "INT64") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return makeInteger64(non_empty_dom); + } else if (typestr == "UINT64") { + std::vector ned(2); + fi->get_non_empty_domain(fid, did, &ned[0]); + std::vector v{ static_cast(ned[0]), static_cast(ned[1]) }; + return makeInteger64(v); + } else if (typestr == "INT32") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "UINT32") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "INT16") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "UINT16") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "INT8") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "UINT8") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "FLOAT64") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "FLOAT32") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "DATETIME_YEAR" || + typestr == "DATETIME_MONTH" || + typestr == "DATETIME_WEEK" || + typestr == "DATETIME_DAY" || + typestr == "DATETIME_HR" || + typestr == "DATETIME_MIN" || + typestr == "DATETIME_SEC" || + typestr == "DATETIME_MS" || + typestr == "DATETIME_US" || + typestr == "DATETIME_PS" || + typestr == "DATETIME_FS" || + typestr == "DATETIME_AS" ) { + // type_check() from exception.h gets invoked and wants an int64_t + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return makeInteger64(non_empty_dom); + } else if (typestr == "DATETIME_NS") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); + return makeNanotime(non_empty_dom); + } else { + Rcpp::stop("Currently unsupported tiledb domain type: '%s'", typestr.c_str()); + return NumericVector::create(NA_REAL, NA_REAL); // not reached + } +#else + return NumericVector::create(NA_REAL, NA_REAL); +#endif } // [[Rcpp::export]] Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_name(XPtr fi, int32_t fid, - const std::string& dim_name) { - std::vector non_empty_dom(2); - fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); - return makeInteger64(non_empty_dom); + const std::string& dim_name, + const std::string& typestr) { +#if TILEDB_VERSION >= TileDB_Version(2,0,0) + if (typestr == "INT64") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return makeInteger64(non_empty_dom); + } else if (typestr == "UINT64") { + std::vector ned(2); + fi->get_non_empty_domain(fid, dim_name, &ned[0]); + std::vector v{ static_cast(ned[0]), static_cast(ned[1]) }; + return makeInteger64(v); + } else if (typestr == "INT32") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "UINT32") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "INT16") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "UINT16") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "INT8") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "UINT8") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "FLOAT64") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "FLOAT32") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return NumericVector::create(non_empty_dom[0], non_empty_dom[1]); + } else if (typestr == "DATETIME_YEAR" || + typestr == "DATETIME_MONTH" || + typestr == "DATETIME_WEEK" || + typestr == "DATETIME_DAY" || + typestr == "DATETIME_HR" || + typestr == "DATETIME_MIN" || + typestr == "DATETIME_SEC" || + typestr == "DATETIME_MS" || + typestr == "DATETIME_US" || + typestr == "DATETIME_PS" || + typestr == "DATETIME_FS" || + typestr == "DATETIME_AS" ) { + // type_check() from exception.h gets invoked and wants an int64_t + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return makeInteger64(non_empty_dom); + } else if (typestr == "DATETIME_NS") { + std::vector non_empty_dom(2); + fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); + return makeNanotime(non_empty_dom); + } else { + Rcpp::stop("Currently unsupported tiledb domain type: '%s'", typestr.c_str()); + return NumericVector::create(NA_REAL, NA_REAL); // not reached + } +#else + return NumericVector::create(NA_REAL, NA_REAL); +#endif } // [[Rcpp::export]] From c201cc4b4d639dd98b3cdb4caa40f634d413f08e Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Sat, 21 Aug 2021 11:05:29 -0500 Subject: [PATCH 04/10] type string is now optional --- R/FragmentInfo.R | 16 ++++++++++++++-- ...b_fragment_info_get_non_empty_domain_index.Rd | 3 ++- ...db_fragment_info_get_non_empty_domain_name.Rd | 3 ++- 3 files changed, 18 insertions(+), 4 deletions(-) diff --git a/R/FragmentInfo.R b/R/FragmentInfo.R index da1be63489..5f67d07c19 100644 --- a/R/FragmentInfo.R +++ b/R/FragmentInfo.R @@ -64,10 +64,15 @@ tiledb_fragment_info_uri <- function(object, fid) { #' @param object A TileDB fragment info object #' @param fid A fragment object index #' @param did A domain index -#' @param typestr A character variable describing the data type +#' @param typestr An optional character variable describing the data type which will +#' be accessed from the schema if missinh #' @return A TileDB Domain object #' @export tiledb_fragment_info_get_non_empty_domain_index <- function(object, fid, did, typestr) { + if (missing(typestr)) { + uri <- dirname(libtiledb_fragment_info_uri(object@ptr, fid)) + typestr <- datatype( dimensions(domain(schema(uri)))[[did+1]] ) + } libtiledb_fragment_info_get_non_empty_domain_index(object@ptr, fid, did, typestr) } @@ -78,10 +83,17 @@ tiledb_fragment_info_get_non_empty_domain_index <- function(object, fid, did, ty #' @param object A TileDB fragment info object #' @param fid A fragment object index #' @param dim_name A character variable with the dimension name -#' @param typestr A character variable describing the data type +#' @param typestr An optional character variable describing the data type which will +#' be accessed from the schema if missinh #' @return A TileDB Domain object #' @export tiledb_fragment_info_get_non_empty_domain_name <- function(object, fid, dim_name, typestr) { + if (missing(typestr)) { + uri <- dirname(libtiledb_fragment_info_uri(object@ptr, fid)) + names <- sapply(dimensions(domain(schema(uri))), name) + ind <- which(names == dim_name) + typestr <- datatype( dimensions(domain(schema(uri)))[[ind]] ) + } libtiledb_fragment_info_get_non_empty_domain_name(object@ptr, fid, dim_name, typestr) } diff --git a/man/tiledb_fragment_info_get_non_empty_domain_index.Rd b/man/tiledb_fragment_info_get_non_empty_domain_index.Rd index 6b9e34273e..d381a87198 100644 --- a/man/tiledb_fragment_info_get_non_empty_domain_index.Rd +++ b/man/tiledb_fragment_info_get_non_empty_domain_index.Rd @@ -13,7 +13,8 @@ tiledb_fragment_info_get_non_empty_domain_index(object, fid, did, typestr) \item{did}{A domain index} -\item{typestr}{A character variable describing the data type} +\item{typestr}{An optional character variable describing the data type which will +be accessed from the schema if missinh} } \value{ A TileDB Domain object diff --git a/man/tiledb_fragment_info_get_non_empty_domain_name.Rd b/man/tiledb_fragment_info_get_non_empty_domain_name.Rd index 7b4bbe1530..1a9ad79fa0 100644 --- a/man/tiledb_fragment_info_get_non_empty_domain_name.Rd +++ b/man/tiledb_fragment_info_get_non_empty_domain_name.Rd @@ -13,7 +13,8 @@ tiledb_fragment_info_get_non_empty_domain_name(object, fid, dim_name, typestr) \item{dim_name}{A character variable with the dimension name} -\item{typestr}{A character variable describing the data type} +\item{typestr}{An optional character variable describing the data type which will +be accessed from the schema if missinh} } \value{ A TileDB Domain object From 6a9263e53823cb2e828fe8f2ac959171c029c6fa Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Sun, 22 Aug 2021 09:16:58 -0500 Subject: [PATCH 05/10] minor corrections and additions to fragment info --- NAMESPACE | 2 ++ R/FragmentInfo.R | 13 +++++++++++-- R/RcppExports.R | 4 ++++ man/tiledb_fragment_info_get_num.Rd | 10 +--------- man/tiledb_fragment_info_get_size.Rd | 19 +++++++++++++++++++ man/tiledb_fragment_info_get_to_vacuum_num.Rd | 17 +++++++++++++++++ src/RcppExports.cpp | 12 ++++++++++++ src/libtiledb.cpp | 5 +++++ 8 files changed, 71 insertions(+), 11 deletions(-) create mode 100644 man/tiledb_fragment_info_get_size.Rd create mode 100644 man/tiledb_fragment_info_get_to_vacuum_num.Rd diff --git a/NAMESPACE b/NAMESPACE index 579bb03e80..37c031130d 100644 --- a/NAMESPACE +++ b/NAMESPACE @@ -120,7 +120,9 @@ export(tiledb_fragment_info_get_non_empty_domain_name) export(tiledb_fragment_info_get_non_empty_domain_var_index) export(tiledb_fragment_info_get_non_empty_domain_var_name) export(tiledb_fragment_info_get_num) +export(tiledb_fragment_info_get_size) export(tiledb_fragment_info_get_timestamp_range) +export(tiledb_fragment_info_get_to_vacuum_num) export(tiledb_fragment_info_get_to_vacuum_uri) export(tiledb_fragment_info_get_unconsolidated_metadata_num) export(tiledb_fragment_info_get_version) diff --git a/R/FragmentInfo.R b/R/FragmentInfo.R index 5f67d07c19..8056b4c85d 100644 --- a/R/FragmentInfo.R +++ b/R/FragmentInfo.R @@ -134,7 +134,7 @@ tiledb_fragment_info_get_num <- function(object) { #' @param fid A fragment object index #' @return A numeric variable with the number of fragments #' @export -tiledb_fragment_info_get_num <- function(object, fid) { +tiledb_fragment_info_get_size <- function(object, fid) { libtiledb_fragment_info_size(object@ptr, fid) } @@ -208,6 +208,15 @@ tiledb_fragment_info_get_unconsolidated_metadata_num <- function(object, fid) { libtiledb_fragment_info_unconsolidated_metadata_num(object@ptr, fid) } +#' Return the number of fragment info elements to be vacuumed +#' +#' @param object A TileDB fragment info object +#' @return A numeric value with the number of to be vacuumed fragments +#' @export +tiledb_fragment_info_get_to_vacuum_num <- function(object) { + libtiledb_fragment_info_to_vacuum_num(object@ptr) +} + #' Return fragment info URI of the to be vacuumed index #' #' @param object A TileDB fragment info object @@ -215,7 +224,7 @@ tiledb_fragment_info_get_unconsolidated_metadata_num <- function(object, fid) { #' @return A character variable with the URI of the be vacuumed index #' @export tiledb_fragment_info_get_to_vacuum_uri <- function(object, fid) { - libtiledb_fragment_info_to_vaccum_uri(object@ptr, fid) + libtiledb_fragment_info_to_vacuum_uri(object@ptr, fid) } #' Dump the fragment info to console diff --git a/R/RcppExports.R b/R/RcppExports.R index c4d3febc7e..3775972f69 100644 --- a/R/RcppExports.R +++ b/R/RcppExports.R @@ -885,6 +885,10 @@ libtiledb_fragment_info_unconsolidated_metadata_num <- function(fi) { .Call(`_tiledb_libtiledb_fragment_info_unconsolidated_metadata_num`, fi) } +libtiledb_fragment_info_to_vacuum_num <- function(fi) { + .Call(`_tiledb_libtiledb_fragment_info_to_vacuum_num`, fi) +} + libtiledb_fragment_info_to_vacuum_uri <- function(fi, fid) { .Call(`_tiledb_libtiledb_fragment_info_to_vacuum_uri`, fi, fid) } diff --git a/man/tiledb_fragment_info_get_num.Rd b/man/tiledb_fragment_info_get_num.Rd index 5087ac10b5..cb38bf2375 100644 --- a/man/tiledb_fragment_info_get_num.Rd +++ b/man/tiledb_fragment_info_get_num.Rd @@ -4,22 +4,14 @@ \alias{tiledb_fragment_info_get_num} \title{Return a fragment info number of fragments} \usage{ -tiledb_fragment_info_get_num(object, fid) - -tiledb_fragment_info_get_num(object, fid) +tiledb_fragment_info_get_num(object) } \arguments{ \item{object}{A TileDB fragment info object} - -\item{fid}{A fragment object index} } \value{ -A numeric variable with the number of fragments - A numeric variable with the number of fragments } \description{ Return a fragment info number of fragments - -Return a fragment info fragment size for a given fragment index } diff --git a/man/tiledb_fragment_info_get_size.Rd b/man/tiledb_fragment_info_get_size.Rd new file mode 100644 index 0000000000..123bf2b330 --- /dev/null +++ b/man/tiledb_fragment_info_get_size.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_size} +\alias{tiledb_fragment_info_get_size} +\title{Return a fragment info fragment size for a given fragment index} +\usage{ +tiledb_fragment_info_get_size(object, fid) +} +\arguments{ +\item{object}{A TileDB fragment info object} + +\item{fid}{A fragment object index} +} +\value{ +A numeric variable with the number of fragments +} +\description{ +Return a fragment info fragment size for a given fragment index +} diff --git a/man/tiledb_fragment_info_get_to_vacuum_num.Rd b/man/tiledb_fragment_info_get_to_vacuum_num.Rd new file mode 100644 index 0000000000..c109a89f2e --- /dev/null +++ b/man/tiledb_fragment_info_get_to_vacuum_num.Rd @@ -0,0 +1,17 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/FragmentInfo.R +\name{tiledb_fragment_info_get_to_vacuum_num} +\alias{tiledb_fragment_info_get_to_vacuum_num} +\title{Return the number of fragment info elements to be vacuumed} +\usage{ +tiledb_fragment_info_get_to_vacuum_num(object) +} +\arguments{ +\item{object}{A TileDB fragment info object} +} +\value{ +A numeric value with the number of to be vacuumed fragments +} +\description{ +Return the number of fragment info elements to be vacuumed +} diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp index dc3c49c6c4..97fa6ab546 100644 --- a/src/RcppExports.cpp +++ b/src/RcppExports.cpp @@ -2641,6 +2641,17 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// libtiledb_fragment_info_to_vacuum_num +double libtiledb_fragment_info_to_vacuum_num(XPtr fi); +RcppExport SEXP _tiledb_libtiledb_fragment_info_to_vacuum_num(SEXP fiSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< XPtr >::type fi(fiSEXP); + rcpp_result_gen = Rcpp::wrap(libtiledb_fragment_info_to_vacuum_num(fi)); + return rcpp_result_gen; +END_RCPP +} // libtiledb_fragment_info_to_vacuum_uri std::string libtiledb_fragment_info_to_vacuum_uri(XPtr fi, int32_t fid); RcppExport SEXP _tiledb_libtiledb_fragment_info_to_vacuum_uri(SEXP fiSEXP, SEXP fidSEXP) { @@ -2886,6 +2897,7 @@ static const R_CallMethodDef CallEntries[] = { {"_tiledb_libtiledb_fragment_info_version", (DL_FUNC) &_tiledb_libtiledb_fragment_info_version, 2}, {"_tiledb_libtiledb_fragment_info_has_consolidated_metadata", (DL_FUNC) &_tiledb_libtiledb_fragment_info_has_consolidated_metadata, 2}, {"_tiledb_libtiledb_fragment_info_unconsolidated_metadata_num", (DL_FUNC) &_tiledb_libtiledb_fragment_info_unconsolidated_metadata_num, 1}, + {"_tiledb_libtiledb_fragment_info_to_vacuum_num", (DL_FUNC) &_tiledb_libtiledb_fragment_info_to_vacuum_num, 1}, {"_tiledb_libtiledb_fragment_info_to_vacuum_uri", (DL_FUNC) &_tiledb_libtiledb_fragment_info_to_vacuum_uri, 2}, {"_tiledb_libtiledb_fragment_info_dump", (DL_FUNC) &_tiledb_libtiledb_fragment_info_dump, 1}, {NULL, NULL, 0} diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index 3201cb1b34..d077a66b64 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -3959,6 +3959,11 @@ double libtiledb_fragment_info_unconsolidated_metadata_num(XPtr(fi->unconsolidated_metadata_num()); } +// [[Rcpp::export]] +double libtiledb_fragment_info_to_vacuum_num(XPtr fi) { + return static_cast(fi->to_vacuum_num()); +} + // [[Rcpp::export]] std::string libtiledb_fragment_info_to_vacuum_uri(XPtr fi, int32_t fid) { return fi->to_vacuum_uri(static_cast(fid)); From a2ee59b529fdae325798df7fa88faba7acd8f09c Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Sun, 22 Aug 2021 10:16:36 -0500 Subject: [PATCH 06/10] correct one interface --- R/FragmentInfo.R | 5 ++--- man/tiledb_fragment_info_get_unconsolidated_metadata_num.Rd | 4 +--- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/R/FragmentInfo.R b/R/FragmentInfo.R index 8056b4c85d..45fec3c672 100644 --- a/R/FragmentInfo.R +++ b/R/FragmentInfo.R @@ -201,11 +201,10 @@ tiledb_fragment_info_has_consolidated_metadata <- function(object, fid) { #' Return fragment info number of unconsolidated metadata #' #' @param object A TileDB fragment info object -#' @param fid A fragment object index #' @return A numeric value with the number of unconsolidated metadata #' @export -tiledb_fragment_info_get_unconsolidated_metadata_num <- function(object, fid) { - libtiledb_fragment_info_unconsolidated_metadata_num(object@ptr, fid) +tiledb_fragment_info_get_unconsolidated_metadata_num <- function(object) { + libtiledb_fragment_info_unconsolidated_metadata_num(object@ptr) } #' Return the number of fragment info elements to be vacuumed diff --git a/man/tiledb_fragment_info_get_unconsolidated_metadata_num.Rd b/man/tiledb_fragment_info_get_unconsolidated_metadata_num.Rd index 60aae17214..ffdc527059 100644 --- a/man/tiledb_fragment_info_get_unconsolidated_metadata_num.Rd +++ b/man/tiledb_fragment_info_get_unconsolidated_metadata_num.Rd @@ -4,12 +4,10 @@ \alias{tiledb_fragment_info_get_unconsolidated_metadata_num} \title{Return fragment info number of unconsolidated metadata} \usage{ -tiledb_fragment_info_get_unconsolidated_metadata_num(object, fid) +tiledb_fragment_info_get_unconsolidated_metadata_num(object) } \arguments{ \item{object}{A TileDB fragment info object} - -\item{fid}{A fragment object index} } \value{ A numeric value with the number of unconsolidated metadata From 8512b8420d9c598e61b04be0345e1e2f0ce6018e Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Sun, 22 Aug 2021 10:17:03 -0500 Subject: [PATCH 07/10] update one test assuming a sort order which changed --- inst/tinytest/test_dimsubset.R | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/inst/tinytest/test_dimsubset.R b/inst/tinytest/test_dimsubset.R index 8fa25e428b..79f2b6eed3 100644 --- a/inst/tinytest/test_dimsubset.R +++ b/inst/tinytest/test_dimsubset.R @@ -72,7 +72,7 @@ newarr <- tiledb_array(tmp, as.data.frame=TRUE) dat <- newarr[] expect_equal(nrow(dat), nrow(flights)) ## compare some columns, as we re-order comparing all trickers -expect_equal(dat$carrier, sort(as.character(flights$carrier))) +expect_equal(sort(dat$carrier), sort(as.character(flights$carrier))) expect_equal(table(dat$origin), table(flights$origin)) ## test list of four with one null From 3ba2ef265923b26e4112c349c8ad7e2b4037a355 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Sun, 22 Aug 2021 10:30:45 -0500 Subject: [PATCH 08/10] permit compilation under TileDB older than 2.2.* --- inst/include/tiledb.h | 9 +++++- src/libtiledb.cpp | 66 +++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 72 insertions(+), 3 deletions(-) diff --git a/inst/include/tiledb.h b/inst/include/tiledb.h index c311d78110..8ad9ac8c42 100644 --- a/inst/include/tiledb.h +++ b/inst/include/tiledb.h @@ -68,7 +68,6 @@ struct vfs_fh { }; typedef struct vfs_fh vfs_fh_t; - #if TILEDB_VERSION_MAJOR == 2 && TILEDB_VERSION_MINOR < 3 // we need a placeholder as tiledb::QueryCondition is in at least one function signature namespace tiledb { @@ -77,4 +76,12 @@ namespace tiledb { } #endif +#if TILEDB_VERSION_MAJOR == 2 && TILEDB_VERSION_MINOR < 2 +// we need a placeholder as tiledb::FragmentInfo is in function signatures +namespace tiledb { + class FragmentInfo { + }; +} +#endif + #endif // __tiledb_h__ diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index d077a66b64..10a752e422 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -3733,22 +3733,30 @@ std::string libtiledb_stats_raw_get() { // [[Rcpp::export]] XPtr libtiledb_fragment_info(XPtr ctx, const std::string& uri) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) auto ptr = XPtr(new tiledb::FragmentInfo(*ctx.get(), uri)); registerXptrFinalizer(ptr, libtiledb_fragment_info_delete); ptr->load(); // also load +#else + auto ptr = XPtr(new tiledb::FragmentInfo()); // placeholder class to permit compilation +#endif return ptr; } // [[Rcpp::export]] std::string libtiledb_fragment_info_uri(XPtr fi, int32_t fid) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return fi->fragment_uri(static_cast(fid)); +#else + return std::string("NA"); +#endif } // [[Rcpp::export]] Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_index(XPtr fi, int32_t fid, int32_t did, const std::string& typestr) { -#if TILEDB_VERSION >= TileDB_Version(2,0,0) +#if TILEDB_VERSION >= TileDB_Version(2,2,0) if (typestr == "INT64") { std::vector non_empty_dom(2); fi->get_non_empty_domain(fid, did, &non_empty_dom[0]); @@ -3824,7 +3832,7 @@ Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_name(XPtr= TileDB_Version(2,0,0) +#if TILEDB_VERSION >= TileDB_Version(2,2,0) if (typestr == "INT64") { std::vector non_empty_dom(2); fi->get_non_empty_domain(fid, dim_name, &non_empty_dom[0]); @@ -3899,8 +3907,12 @@ Rcpp::NumericVector libtiledb_fragment_info_get_non_empty_domain_name(XPtr fi, int32_t fid, int32_t did) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) auto sp = fi->non_empty_domain_var(static_cast(fid), static_cast(did)); return CharacterVector::create(sp.first, sp.second); +#else + return CharacterVector::create(NA_STRING, NA_STRING); +#endif } // [[Rcpp::export]] @@ -3908,68 +3920,118 @@ Rcpp::CharacterVector libtiledb_fragment_info_get_non_empty_domain_var_name(XPtr fi, int32_t fid, const std::string& dim_name) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) auto sp = fi->non_empty_domain_var(static_cast(fid), dim_name); return CharacterVector::create(sp.first, sp.second); +#else + return CharacterVector::create(NA_STRING, NA_STRING); +#endif } // [[Rcpp::export]] double libtiledb_fragment_info_num(XPtr fi) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return static_cast(fi->fragment_num()); +#else + return NA_REAL; +#endif } // [[Rcpp::export]] double libtiledb_fragment_info_size(XPtr fi, int32_t fid) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return static_cast(fi->fragment_size(static_cast(fid))); +#else + return NA_REAL; +#endif } // [[Rcpp::export]] bool libtiledb_fragment_info_dense(XPtr fi, int32_t fid) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return fi->dense(static_cast(fid)); +#else + return NA_LOGICAL; +#endif } // [[Rcpp::export]] bool libtiledb_fragment_info_sparse(XPtr fi, int32_t fid) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return fi->sparse(static_cast(fid)); +#else + return NA_LOGICAL; +#endif } // [[Rcpp::export]] Rcpp::DatetimeVector libtiledb_fragment_info_timestamp_range(XPtr fi, int32_t fid) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) auto range = fi->timestamp_range(static_cast(fid)); return Rcpp::DatetimeVector::create(range.first/1000.0, range.second/1000.0); +#else + return DatetimeVector::create(NA_REAL, NA_REAL); +#endif } // [[Rcpp::export]] double libtiledb_fragment_info_cell_num(XPtr fi, int32_t fid) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return static_cast(fi->cell_num(static_cast(fid))); +#else + return NA_REAL; +#endif } // [[Rcpp::export]] int libtiledb_fragment_info_version(XPtr fi, int32_t fid) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return static_cast(fi->version(static_cast(fid))); +#else + return NA_INTEGER; +#endif } // [[Rcpp::export]] bool libtiledb_fragment_info_has_consolidated_metadata(XPtr fi, int32_t fid) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return fi->has_consolidated_metadata(static_cast(fid)); +#else + return NA_LOGICAL; +#endif } // [[Rcpp::export]] double libtiledb_fragment_info_unconsolidated_metadata_num(XPtr fi) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return static_cast(fi->unconsolidated_metadata_num()); +#else + return NA_REAL; +#endif } // [[Rcpp::export]] double libtiledb_fragment_info_to_vacuum_num(XPtr fi) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return static_cast(fi->to_vacuum_num()); +#else + return NA_REAL; +#endif } // [[Rcpp::export]] std::string libtiledb_fragment_info_to_vacuum_uri(XPtr fi, int32_t fid) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return fi->to_vacuum_uri(static_cast(fid)); +#else + return std::string("NA"); +#endif } // [[Rcpp::export]] void libtiledb_fragment_info_dump(XPtr fi) { +#if TILEDB_VERSION >= TileDB_Version(2,2,0) return fi->dump(); +#endif } From de543a5523c3d89a08c0d9169f69f5eda9e96063 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Sun, 22 Aug 2021 11:17:27 -0500 Subject: [PATCH 09/10] ensure implicit finalizer is off when explicit one added --- src/libtiledb.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/libtiledb.cpp b/src/libtiledb.cpp index 10a752e422..e8ea956ac6 100644 --- a/src/libtiledb.cpp +++ b/src/libtiledb.cpp @@ -3326,11 +3326,11 @@ tiledb_query_condition_combination_op_t _tiledb_query_string_to_condition_combin // [[Rcpp::export]] XPtr libtiledb_query_condition(XPtr ctx) { #if TILEDB_VERSION >= TileDB_Version(2,3,0) - XPtr query_cond(new tiledb::QueryCondition(*ctx.get())); + XPtr query_cond(new tiledb::QueryCondition(*ctx.get()), false); #else - XPtr query_cond(new tiledb::QueryCondition()); + XPtr query_cond(new tiledb::QueryCondition(), false); #endif - //registerXptrFinalizer(query_cond, libtiledb_query_condition_delete); + registerXptrFinalizer(query_cond, libtiledb_query_condition_delete); return query_cond; } @@ -3369,11 +3369,11 @@ XPtr libtiledb_query_condition_combine(XPtr= TileDB_Version(2,3,0) tiledb_query_condition_combination_op_t op = _tiledb_query_string_to_condition_combination_op(str); tiledb::QueryCondition res = lhs->combine(*rhs.get(), op); - auto query_cond = XPtr(new tiledb::QueryCondition(res)); + auto query_cond = XPtr(new tiledb::QueryCondition(res), false); #else - XPtr query_cond(new tiledb::QueryCondition()); + XPtr query_cond(new tiledb::QueryCondition(), false); #endif - //registerXptrFinalizer(query_cond, libtiledb_query_condition_delete); + registerXptrFinalizer(query_cond, libtiledb_query_condition_delete); return query_cond; } @@ -3734,7 +3734,7 @@ std::string libtiledb_stats_raw_get() { XPtr libtiledb_fragment_info(XPtr ctx, const std::string& uri) { #if TILEDB_VERSION >= TileDB_Version(2,2,0) - auto ptr = XPtr(new tiledb::FragmentInfo(*ctx.get(), uri)); + auto ptr = XPtr(new tiledb::FragmentInfo(*ctx.get(), uri), false); registerXptrFinalizer(ptr, libtiledb_fragment_info_delete); ptr->load(); // also load #else From d0df14c491a1d3c00a6ebb379e47e05b80f70078 Mon Sep 17 00:00:00 2001 From: Dirk Eddelbuettel Date: Sun, 22 Aug 2021 11:24:19 -0500 Subject: [PATCH 10/10] add test file for fragment info --- inst/tinytest/test_fragmentinfo.R | 68 +++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 inst/tinytest/test_fragmentinfo.R diff --git a/inst/tinytest/test_fragmentinfo.R b/inst/tinytest/test_fragmentinfo.R new file mode 100644 index 0000000000..b4024c1095 --- /dev/null +++ b/inst/tinytest/test_fragmentinfo.R @@ -0,0 +1,68 @@ +library(tinytest) +library(tiledb) + +if (tiledb_version(TRUE) < "2.2.0") exit_file("Needs TileDB 2.2.* or later") + +isOldWindows <- Sys.info()[["sysname"]] == "Windows" && grepl('Windows Server 2008', osVersion) +if (isOldWindows) exit_file("skip this file on old Windows releases") + +ctx <- tiledb_ctx(limitTileDBCores()) + +uri <- tempfile() +if (dir.exists(uri)) unlink(uri, TRUE) + +## create simple array +set.seed(123) +D1 <- data.frame(keys = 1:10, + groups = replicate(10, paste0(sample(LETTERS[1:4], 3), collapse="")), + vals = sample(100, 10, TRUE)) +fromDataFrame(D1, uri, col_index=1:2, sparse=TRUE, tile_domain=list(keys=c(1L, 1000L))) + +fraginf <- tiledb_fragment_info(uri) + +expect_true(isS4(fraginf)) +expect_true(is(fraginf@ptr, "externalptr")) + +furi <- tiledb_fragment_info_uri(fraginf, 0) +expect_true(is.character(furi)) +#expect_true(tiledb_vfs_is_dir(furi)) + +ned <- tiledb_fragment_info_get_non_empty_domain_index(fraginf, 0, 0) +expect_equal(ned, c(1, 10)) +ned <- tiledb_fragment_info_get_non_empty_domain_name(fraginf, 0, "keys") +expect_equal(ned, c(1, 10)) +ned <- tiledb_fragment_info_get_non_empty_domain_index(fraginf, 0, 0) + +ned <- tiledb_fragment_info_get_non_empty_domain_var_index(fraginf, 0, 1) +expect_true(is.character(ned)) +expect_equal(length(ned), 2) + +expect_equal(tiledb_fragment_info_get_num(fraginf), 1) +expect_true(tiledb_fragment_info_get_size(fraginf, 0) > 2000) # 2389 on my machine ... but may vary + +expect_false(tiledb_fragment_info_dense(fraginf, 0)) +expect_true(tiledb_fragment_info_sparse(fraginf, 0)) + +rng <- tiledb_fragment_info_get_timestamp_range(fraginf, 0) +expect_true(inherits(rng, "POSIXt")) +expect_equal(length(rng), 2) +expect_equal(as.Date(rng[1]), Sys.Date()) # very coarse :) + +expect_equal(tiledb_fragment_info_get_cell_num(fraginf, 0), 10) + +expect_true(tiledb_fragment_info_get_version(fraginf, 0) > 5) # we may test with older core libs + +expect_false(tiledb_fragment_info_has_consolidated_metadata(fraginf, 0)) + +expect_equal(tiledb_fragment_info_get_to_vacuum_num(fraginf), 0) + +D2 <- data.frame(keys = 11:20, + groups = replicate(10, paste0(sample(LETTERS[1:4], 3), collapse="")), + vals = sample(100, 10, TRUE)) +arr <- tiledb_array(uri, "WRITE") +arr[] <- D2 + +rm(fraginf) +fraginf <- tiledb_fragment_info(uri) +expect_equal(tiledb_fragment_info_get_num(fraginf), 2) +expect_equal(tiledb_fragment_info_get_to_vacuum_num(fraginf), 0)