[c++] Hide internal dimensions

libtiledbsoma/src/soma/managed_query.cc

@@ -157,6 +157,14 @@ void ManagedQuery::setup_read() {
         for (int i = 0; i < attribute_num; i++) {
             columns_.push_back(schema.attribute(i).name());
         }
+
+        auto is_internal = [](std::string name) {
+            return name.rfind(SOMA_GEOMETRY_DIMENSION_PREFIX, 0) == 0;
+        };
+
+        auto internal_end = std::remove_if(
+            columns_.begin(), columns_.end(), is_internal);
+        columns_.erase(internal_end, columns_.end());
     }
 
     // Allocate and attach buffers

libtiledbsoma/src/soma/soma_array.h

@@ -33,9 +33,8 @@
 #ifndef SOMA_ARRAY
 #define SOMA_ARRAY
 
-#include <stdexcept>  // for windows: error C2039: 'runtime_error': is not a member of 'std'
-
 #include <future>
+#include <stdexcept>  // for windows: error C2039: 'runtime_error': is not a member of 'std'
 
 #include <tiledb/tiledb>
 #include <tiledb/tiledb_experimental>
@@ -997,7 +996,7 @@
      * @tparam T Domain datatype
      * @return Pair of [lower, upper] inclusive bounds.
      */
-    ArrowTable get_soma_domain() {
+    virtual ArrowTable get_soma_domain() {
         if (has_current_domain()) {
             return _get_core_current_domain();
         } else {
@@ -1020,15 +1019,15 @@
      * @tparam T Domain datatype
      * @return Pair of [lower, upper] inclusive bounds.
      */
-    ArrowTable get_soma_maxdomain() {
+    virtual ArrowTable get_soma_maxdomain() {
         return _get_core_domain();
     }
 
     /**
      * Returns the core non-empty domain in its entirety, as an Arrow
      * table for return to Python/R.
      */
-    ArrowTable get_non_empty_domain() {
+    virtual ArrowTable get_non_empty_domain() {
         return _get_core_domainish(Domainish::kind_non_empty_domain);
     }
 

libtiledbsoma/src/soma/soma_geometry_dataframe.cc

@@ -54,7 +54,6 @@
     std::shared_ptr<SOMAContext> ctx,
     PlatformConfig platform_config,
     std::optional<TimestampRange> timestamp) {
-    std::vector<std::string> spatial_axes;
     auto tiledb_schema = ArrowAdapter::tiledb_schema_from_arrow_schema(
         ctx->tiledb_ctx(),
         schema,
@@ -98,7 +97,20 @@
 
 const std::vector<std::string> SOMAGeometryDataFrame::index_column_names()
     const {
-    return this->dimension_names();
+    std::vector<std::string> dim_names = this->dimension_names();
+
+    auto is_internal = [](std::string name) {
+        return name.rfind(SOMA_GEOMETRY_DIMENSION_PREFIX, 0) == 0;
+    };
+
+    auto first_dim = std::find_if(
+        begin(dim_names), end(dim_names), is_internal);
+    dim_names.insert(first_dim, SOMA_GEOMETRY_COLUMN_NAME);
+    auto internal_end = std::remove_if(
+        begin(dim_names), end(dim_names), is_internal);
+    dim_names.erase(internal_end, dim_names.end());
+
+    return dim_names;
 }
 
 const std::vector<std::string> SOMAGeometryDataFrame::spatial_column_names()
@@ -172,6 +184,18 @@
     SOMAArray::set_array_data(std::move(arrow_schema), std::move(arrow_array));
 }
 
+ArrowTable SOMAGeometryDataFrame::get_soma_domain() {
+    return _reconstruct_geometry_domain(SOMAArray::get_soma_domain());
+}
+
+ArrowTable SOMAGeometryDataFrame::get_soma_maxdomain() {
+    return _reconstruct_geometry_domain(SOMAArray::get_soma_maxdomain());
+}
+
+ArrowTable SOMAGeometryDataFrame::get_non_empty_domain() {
+    return _reconstruct_geometry_domain(SOMAArray::get_non_empty_domain());
+}
+
 //===================================================================
 //= private non-static
 //===================================================================
@@ -352,4 +376,51 @@
     return ArrowTable(std::move(arrow_array), std::move(arrow_schema));
 }
 
+ArrowTable SOMAGeometryDataFrame::_reconstruct_geometry_domain(
+    const ArrowTable& domain) {
+    std::unique_ptr<ArrowSchema> schema = std::make_unique<ArrowSchema>(
+        ArrowSchema{});
+    std::unique_ptr<ArrowArray> array = std::make_unique<ArrowArray>(
+        ArrowArray{});
+
+    int64_t internal_axes = 2 * spatial_column_names().size();
+
+    NANOARROW_THROW_NOT_OK(
+        ArrowSchemaInitFromType(schema.get(), NANOARROW_TYPE_STRUCT));
+    NANOARROW_THROW_NOT_OK(ArrowSchemaAllocateChildren(
+        schema.get(), domain.second->n_children - internal_axes + 1));
+    NANOARROW_THROW_NOT_OK(
+        ArrowArrayInitFromType(array.get(), NANOARROW_TYPE_STRUCT));
+    NANOARROW_THROW_NOT_OK(ArrowArrayAllocateChildren(
+        array.get(), domain.first->n_children - internal_axes + 1));
+
+    std::vector<std::string> dim_names = this->dimension_names();
+    auto is_internal = [](std::string name) {
+        return name.rfind(SOMA_GEOMETRY_DIMENSION_PREFIX, 0) == 0;
+    };
+    auto first_dim = static_cast<int64_t>(
+        std::find_if(begin(dim_names), end(dim_names), is_internal) -
+        dim_names.begin());
+
+    for (int64_t i = 0, orig_i = 0; i < schema->n_children; ++i, ++orig_i) {
+        ArrowSchemaMove(domain.second->children[orig_i], schema->children[i]);
+        ArrowArrayMove(domain.first->children[orig_i], array->children[i]);
+
+        if (i == first_dim) {
+            NANOARROW_THROW_NOT_OK(ArrowSchemaSetName(
+                schema->children[i], SOMA_GEOMETRY_COLUMN_NAME.c_str()));
+            std::vector<double_t> data;
+            for (; orig_i < i + internal_axes; orig_i += 2) {
+                data.push_back(
+                    ((double_t*)domain.first->children[orig_i]->buffers[1])[0]);
+                data.push_back(
+                    ((double_t*)domain.first->children[orig_i]->buffers[1])[1]);
+            }
+            array->children[i] = ArrowAdapter::make_arrow_array_child(data);
+        }
+    }
+
+    return ArrowTable(std::move(array), std::move(schema));
+}
+
 }  // namespace tiledbsoma

libtiledbsoma/src/soma/soma_geometry_dataframe.h

@@ -33,6 +33,7 @@
 #ifndef SOMA_GEOMETRY_DATAFRAME
 #define SOMA_GEOMETRY_DATAFRAME
 
+#include <algorithm>
 #include <filesystem>
 #include <vector>
 
@@ -175,10 +176,75 @@ class SOMAGeometryDataFrame : virtual public SOMAArray {
      */
     uint64_t count();
 
+    /**
+     * @brief Set the spatial axis slice using multiple ranges
+     *
+     * @note Partitioning is not supported
+     *
+     * @tparam T
+     * @param axis
+     * @param ranges
+     */
+    template <typename T>
+    void set_spatial_dim_ranges(
+        const std::string& axis, const std::vector<std::pair<T, T>>& ranges) {
+        std::vector<std::pair<T, T>> min_range;
+        std::vector<std::pair<T, T>> max_range;
+
+        if (ranges.size() != 1) {
+            throw TileDBSOMAError(
+                "Multi ranges are not supported for axis dimensions");
+        }
+
+        T min_domain, max_domain;
+
+        // Both min and max dimension share the same domain
+        if (ArraySchemaExperimental::current_domain(
+                *this->ctx()->tiledb_ctx(), *this->tiledb_schema())
+                .is_empty()) {
+            std::pair<T, T> domain = this->tiledb_schema()
+                                         ->domain()
+                                         .dimension(
+                                             SOMA_GEOMETRY_DIMENSION_PREFIX +
+                                             axis + "__min")
+                                         .domain<T>();
+            min_domain = domain.first;
+            max_domain = domain.second;
+        } else {
+            auto current_domain = ArraySchemaExperimental::current_domain(
+                                      *this->ctx()->tiledb_ctx(),
+                                      *this->tiledb_schema().get())
+                                      .ndrectangle()
+                                      .range<T>(
+                                          SOMA_GEOMETRY_DIMENSION_PREFIX +
+                                          axis + "__min");
+            min_domain = current_domain[0];
+            max_domain = current_domain[1];
+        }
+
+        for (const std::pair<T, T>& range : ranges) {
+            min_range.push_back(
+                std::make_pair(min_domain, std::min(range.second, max_domain)));
+            max_range.push_back(
+                std::make_pair(std::max(range.first, min_domain), max_domain));
+        }
+
+        this->set_dim_ranges(
+            SOMA_GEOMETRY_DIMENSION_PREFIX + axis + "__min", min_range);
+        this->set_dim_ranges(
+            SOMA_GEOMETRY_DIMENSION_PREFIX + axis + "__max", max_range);
+    }
+
     void set_array_data(
         std::unique_ptr<ArrowSchema> arrow_schema,
         std::unique_ptr<ArrowArray> arrow_array) override;
 
+    ArrowTable get_soma_domain() override;
+
+    ArrowTable get_soma_maxdomain() override;
+
+    ArrowTable get_non_empty_domain() override;
+
    private:
     //===================================================================
     //= private non-static
@@ -200,6 +266,13 @@ class SOMAGeometryDataFrame : virtual public SOMAArray {
      */
     ArrowTable _reconstruct_geometry_data_table(
         ArrowTable original_data, const std::vector<ArrowTable>& wkb_data);
+
+    /**
+     * @brief Create a new ArrowTable by merging the internal spatial dimensions
+     * and setting the ``soma_geometry`` domain as the stacked domain of each
+     * spatial axis.
+     */
+    ArrowTable _reconstruct_geometry_domain(const ArrowTable& domain);
 };
 }  // namespace tiledbsoma