Make ContextResources available in Enumeration::generate_value_map

Author: rroelke

test/src/unit-enumerations.cc

@@ -465,6 +465,7 @@ HandleLoadArraySchemaRequestFx::create_string_enumeration(
   }
 
   return Enumeration::create(
+      ctx_.resources(),
       name,
       Datatype::STRING_ASCII,
       constants::var_num,
@@ -546,7 +547,7 @@ HandleLoadArraySchemaRequestFx::call_handler(
   REQUIRE(rval == TILEDB_OK);
 
   return serialization::deserialize_load_array_schema_response(
-      uri_, cfg_, stype, resp_buf->buffer(), memory_tracker_);
+      ctx_.resources(), uri_, cfg_, stype, resp_buf->buffer(), memory_tracker_);
 }
 
 shared_ptr<ArraySchema> HandleQueryPlanRequestFx::create_schema() {

test/src/unit-request-handlers.cc

@@ -71,6 +71,7 @@ capi_return_t tiledb_enumeration_alloc(
     memory_tracker->set_type(tiledb::sm::MemoryTrackerType::ENUMERATION_CREATE);
 
     *enumeration = tiledb_enumeration_handle_t::make_handle(
+        ctx->context().resources(),
         std::string(name),
         datatype,
         cell_val_num,
@@ -89,6 +90,7 @@ capi_return_t tiledb_enumeration_alloc(
 }
 
 capi_return_t tiledb_enumeration_extend(
+    tiledb_ctx_t* ctx,
     tiledb_enumeration_t* old_enumeration,
     const void* data,
     uint64_t data_size,
@@ -99,7 +101,7 @@ capi_return_t tiledb_enumeration_extend(
   ensure_output_pointer_is_valid(new_enumeration);
 
   auto new_enmr =
-      old_enumeration->extend(data, data_size, offsets, offsets_size);
+      old_enumeration->extend(ctx, data, data_size, offsets, offsets_size);
 
   try {
     *new_enumeration = tiledb_enumeration_handle_t::make_handle(new_enmr);
@@ -262,7 +264,7 @@ CAPI_INTERFACE(
     const void* offsets,
     uint64_t offsets_size,
     tiledb_enumeration_t** new_enumeration) {
-  return api_entry_context<tiledb::api::tiledb_enumeration_extend>(
+  return api_entry<tiledb::api::tiledb_enumeration_extend>(
       ctx,
       old_enumeration,
       data,

tiledb/api/c_api/enumeration/enumeration_api.cc

@@ -34,6 +34,7 @@
 #define TILEDB_CAPI_ENUMERATION_INTERNAL_H
 
 #include "enumeration_api_experimental.h"
+#include "tiledb/api/c_api/context/context_api_internal.h"
 #include "tiledb/api/c_api_support/handle/handle.h"
 #include "tiledb/common/common.h"
 #include "tiledb/sm/array_schema/enumeration.h"
@@ -82,11 +83,13 @@ struct tiledb_enumeration_handle_t
    * Extend a given enumeration.
    */
   [[nodiscard]] shared_ptr<const tiledb::sm::Enumeration> extend(
+      tiledb_ctx_t* ctx,
       const void* data,
       uint64_t data_size,
       const void* offsets,
       uint64_t offsets_size) const {
-    return enumeration_->extend(data, data_size, offsets, offsets_size);
+    return enumeration_->extend(
+        ctx->context().resources(), data, data_size, offsets, offsets_size);
   }
 
   /**

tiledb/api/c_api/enumeration/enumeration_api_internal.h

@@ -336,7 +336,7 @@ Status Array::open_without_fragments(
         throw instead of return Status */
       if (!use_refactored_array_open()) {
         auto&& [st, array_schema_latest] =
-            rest_client->get_array_schema_from_rest(array_uri_);
+            rest_client->get_array_schema_from_rest(resources_, array_uri_);
         if (!st.ok()) {
           throw StatusException(st);
         }
@@ -499,7 +499,7 @@ Status Array::open(
       }
       if (!use_refactored_array_open()) {
         auto&& [st, array_schema_latest] =
-            rest_client->get_array_schema_from_rest(array_uri_);
+            rest_client->get_array_schema_from_rest(resources_, array_uri_);
         throw_if_not_ok(st);
         set_array_schema_latest(array_schema_latest.value());
         if (serialize_enumerations()) {
@@ -850,6 +850,7 @@ Array::get_enumerations_all_schemas() {
       // Pass an empty list of enumeration names. REST will use timestamps to
       // load all enumerations on all schemas for the array within that range.
       ret = rest_client->post_enumerations_from_rest(
+          resources_,
           array_uri_,
           array_dir_timestamp_start_,
           array_dir_timestamp_end_,
@@ -949,6 +950,7 @@ std::vector<shared_ptr<const Enumeration>> Array::get_enumerations(
       }
 
       loaded = rest_client->post_enumerations_from_rest(
+          resources_,
           array_uri_,
           array_dir_timestamp_start_,
           array_dir_timestamp_end_,
@@ -2137,6 +2139,7 @@ void load_enumeration_into_schema(
     }
 
     auto ret = rest_client->post_enumerations_from_rest(
+        ctx.resources(),
         array_schema.array_uri(),
         array_schema.timestamp_start(),
         array_schema.timestamp_end(),

tiledb/sm/array/array.cc

@@ -746,6 +746,10 @@ class Array {
     return config_;
   }
 
+  inline const ContextResources& resources() const {
+    return resources_;
+  }
+
   /** Directly set the array URI for serialized compatibility with pre
    * TileDB 2.5 clients */
   void set_uri_serialized(const std::string& uri) {

tiledb/sm/array/array.h

@@ -1344,7 +1344,7 @@ shared_ptr<const Enumeration> ArrayDirectory::load_enumeration(
   }
 
   Deserializer deserializer(tile->data(), tile->size());
-  return Enumeration::deserialize(deserializer, memory_tracker);
+  return Enumeration::deserialize(resources_, deserializer, memory_tracker);
 }
 
 }  // namespace tiledb::sm

tiledb/sm/array/array_directory.cc

@@ -245,7 +245,7 @@ shared_ptr<ArraySchema> load_array_schema(
   if (uri.is_tiledb()) {
     auto& rest_client = ctx.rest_client();
     auto&& [st, array_schema_response] =
-        rest_client.get_array_schema_from_rest(uri);
+        rest_client.get_array_schema_from_rest(ctx.resources(), uri);
     throw_if_not_ok(st);
     auto array_schema = std::move(array_schema_response).value();
 
@@ -254,6 +254,7 @@ shared_ptr<ArraySchema> load_array_schema(
       // Pass an empty list of enumeration names. REST will use timestamps to
       // load all enumerations on all schemas for the array within that range.
       auto ret = rest_client.post_enumerations_from_rest(
+          ctx.resources(),
           uri,
           array_schema->timestamp_start(),
           array_schema->timestamp_end(),

tiledb/sm/array_schema/array_schema_operations.cc

@@ -49,6 +49,7 @@ class EnumerationException : public StatusException {
 };
 
 Enumeration::Enumeration(
+    const ContextResources& resources,
     const std::string& name,
     const std::string& path_name,
     Datatype type,
@@ -191,11 +192,13 @@ Enumeration::Enumeration(
     throw_if_not_ok(offsets_.write(offsets, 0, offsets_size));
   }
 
-  generate_value_map();
+  generate_value_map(resources);
 }
 
 shared_ptr<const Enumeration> Enumeration::deserialize(
-    Deserializer& deserializer, shared_ptr<MemoryTracker> memory_tracker) {
+    const ContextResources& resources,
+    Deserializer& deserializer,
+    shared_ptr<MemoryTracker> memory_tracker) {
   auto disk_version = deserializer.read<uint32_t>();
   if (disk_version > constants::enumerations_version) {
     throw EnumerationException(
@@ -233,6 +236,7 @@ shared_ptr<const Enumeration> Enumeration::deserialize(
   }
 
   return create(
+      resources,
       name,
       path_name,
       static_cast<Datatype>(type),
@@ -246,6 +250,7 @@ shared_ptr<const Enumeration> Enumeration::deserialize(
 }
 
 shared_ptr<const Enumeration> Enumeration::extend(
+    const ContextResources& resources,
     const void* data,
     uint64_t data_size,
     const void* offsets,
@@ -326,6 +331,7 @@ shared_ptr<const Enumeration> Enumeration::extend(
   }
 
   return create(
+      resources,
       name_,
       "",
       type_,
@@ -421,7 +427,7 @@ uint64_t Enumeration::index_of(const void* data, uint64_t size) const {
   return iter->second;
 }
 
-void Enumeration::generate_value_map() {
+void Enumeration::generate_value_map(const ContextResources&) {
   auto char_data = data_.data_as<char>();
   if (var_size()) {
     auto offsets = offsets_.data_as<uint64_t>();

tiledb/sm/array_schema/enumeration.cc

@@ -40,6 +40,7 @@
 #include "tiledb/common/types/untyped_datum.h"
 #include "tiledb/sm/buffer/buffer.h"
 #include "tiledb/sm/enums/datatype.h"
+#include "tiledb/sm/storage_manager/context.h"
 #include "tiledb/storage_format/serialization/serializers.h"
 
 namespace tiledb::sm {
@@ -75,6 +76,7 @@ class Enumeration {
 
   /** Create a new Enumeration
    *
+   * @param resources Resources for computing the enumeration value map.
    * @param name The name of this Enumeration as referenced by attributes.
    * @param type The datatype of the enumeration values.
    * @param cell_val_num The cell_val_num of the enumeration.
@@ -91,6 +93,7 @@ class Enumeration {
    * @return shared_ptr<Enumeration> The created enumeration.
    */
   static shared_ptr<const Enumeration> create(
+      const ContextResources& resources,
       const std::string& name,
       Datatype type,
       uint32_t cell_val_num,
@@ -101,6 +104,7 @@ class Enumeration {
       uint64_t offsets_size,
       shared_ptr<MemoryTracker> memory_tracker) {
     return create(
+        resources,
         name,
         "",
         type,
@@ -115,6 +119,7 @@ class Enumeration {
 
   /** Create a new Enumeration
    *
+   * @param resources Resources for computing the enumeration value map.
    * @param name The name of this Enumeration as referenced by attributes.
    * @param path_name The last URI path component of the Enumeration.
    * @param type The datatype of the enumeration values.
@@ -132,6 +137,7 @@ class Enumeration {
    * @return shared_ptr<Enumeration> The created enumeration.
    */
   static shared_ptr<const Enumeration> create(
+      const ContextResources& resources,
       const std::string& name,
       const std::string& path_name,
       Datatype type,
@@ -144,6 +150,7 @@ class Enumeration {
       shared_ptr<MemoryTracker> memory_tracker) {
     struct EnableMakeShared : public Enumeration {
       EnableMakeShared(
+          const ContextResources& resources,
           const std::string& name,
           const std::string& path_name,
           Datatype type,
@@ -155,6 +162,7 @@ class Enumeration {
           uint64_t offsets_size,
           shared_ptr<MemoryTracker> memory_tracker)
           : Enumeration(
+                resources,
                 name,
                 path_name,
                 type,
@@ -169,6 +177,7 @@ class Enumeration {
     };
     return make_shared<EnableMakeShared>(
         HERE(),
+        resources,
         name,
         path_name,
         type,
@@ -189,7 +198,9 @@ class Enumeration {
    * @return A new Enumeration.
    */
   static shared_ptr<const Enumeration> deserialize(
-      Deserializer& deserializer, shared_ptr<MemoryTracker> memory_tracker);
+      const ContextResources& resources,
+      Deserializer& deserializer,
+      shared_ptr<MemoryTracker> memory_tracker);
 
   /**
    * Create a new enumeration by extending an existing enumeration's
@@ -207,6 +218,7 @@ class Enumeration {
    * @return shared_ptr<Enumeration> The extended enumeration.
    */
   shared_ptr<const Enumeration> extend(
+      const ContextResources& resources,
       const void* data,
       uint64_t data_size,
       const void* offsets,
@@ -361,6 +373,7 @@ class Enumeration {
 
   /** Constructor
    *
+   * @param resources Resources for building the enumeration value map.
    * @param name The name of this Enumeration as referenced by attributes.
    * @param path_name The last URI path component of the Enumeration.
    * @param type The datatype of the enumeration values.
@@ -377,6 +390,7 @@ class Enumeration {
    * @param memory_tracker The memory tracker.
    */
   Enumeration(
+      const ContextResources& resources,
       const std::string& name,
       const std::string& path_name,
       Datatype type,
@@ -426,7 +440,7 @@ class Enumeration {
   /* ********************************* */
 
   /** Populate the value_map_ */
-  void generate_value_map();
+  void generate_value_map(const ContextResources& resources);
 
   /**
    * Add a value to value_map_