Changes to loading enumerations.

Author: shaunrd0

test/src/unit-capi-config.cc

@@ -230,7 +230,7 @@ void check_save_to_file() {
   ss << "rest.curl.buffer_size 524288\n";
   ss << "rest.curl.verbose false\n";
   ss << "rest.http_compressor any\n";
-  ss << "rest.load_enumerations_on_array_open true\n";
+  ss << "rest.load_enumerations_on_array_open false\n";
   ss << "rest.load_metadata_on_array_open true\n";
   ss << "rest.load_non_empty_domain_on_array_open true\n";
   ss << "rest.retry_count 25\n";

tiledb/api/c_api/config/config_api_external.h

@@ -740,6 +740,10 @@ TILEDB_EXPORT void tiledb_config_free(tiledb_config_t** config) TILEDB_NOEXCEPT;
  *    If true, array non empty domain will be loaded and sent to server together
  *    with the open array <br>
  *    **Default**: true
+ * - `rest.load_enumerations_on_array_open` <br>
+ *    If true, enumerations will be loaded and sent to server together with
+ *    the open array.
+ *    **Default**: false
  * - `rest.use_refactored_array_open` <br>
  *    If true, the new REST routes and APIs for opening an array
  *    will be used <br>

tiledb/sm/array/array.cc

@@ -804,19 +804,21 @@ void Array::encryption_type(
 
 shared_ptr<const Enumeration> Array::get_enumeration(
     const std::string& enumeration_name) {
-  return get_enumerations({enumeration_name})[0];
+  return get_enumerations(
+      {enumeration_name}, opened_array_->array_schema_latest_ptr())[0];
 }
 
 std::vector<shared_ptr<const Enumeration>> Array::get_enumerations(
-    const std::vector<std::string>& enumeration_names) {
+    const std::vector<std::string>& enumeration_names,
+    shared_ptr<ArraySchema> schema) {
   if (!is_open_) {
     throw ArrayException("Unable to load enumerations; Array is not open.");
   }
 
   // Dedupe requested names and filter out anything already loaded.
   std::unordered_set<std::string> enmrs_to_load;
   for (auto& enmr_name : enumeration_names) {
-    if (array_schema_latest().is_enumeration_loaded(enmr_name)) {
+    if (schema->is_enumeration_loaded(enmr_name)) {
       continue;
     }
     enmrs_to_load.insert(enmr_name);
@@ -850,7 +852,7 @@ std::vector<shared_ptr<const Enumeration>> Array::get_enumerations(
       // Create a vector of paths to be loaded.
       std::vector<std::string> paths_to_load;
       for (auto& enmr_name : enmrs_to_load) {
-        auto path = array_schema_latest().get_enumeration_path_name(enmr_name);
+        auto path = schema->get_enumeration_path_name(enmr_name);
         paths_to_load.push_back(path);
       }
 
@@ -861,14 +863,14 @@ std::vector<shared_ptr<const Enumeration>> Array::get_enumerations(
 
     // Store the loaded enumerations in the schema
     for (auto& enmr : loaded) {
-      opened_array_->array_schema_latest_ptr()->store_enumeration(enmr);
+      schema->store_enumeration(enmr);
     }
   }
 
   // Return the requested list of enumerations
   std::vector<shared_ptr<const Enumeration>> ret(enumeration_names.size());
   for (size_t i = 0; i < enumeration_names.size(); i++) {
-    ret[i] = array_schema_latest().get_enumeration(enumeration_names[i]);
+    ret[i] = schema->get_enumeration(enumeration_names[i]);
   }
   return ret;
 }
@@ -878,7 +880,9 @@ void Array::load_all_enumerations() {
     throw ArrayException("Unable to load all enumerations; Array is not open.");
   }
   // Load all enumerations, discarding the returned list of loaded enumerations.
-  get_enumerations(array_schema_latest().get_enumeration_names());
+  for (const auto& schema : array_schemas_all()) {
+    get_enumerations(schema.second->get_enumeration_names(), schema.second);
+  }
 }
 
 bool Array::is_empty() const {

tiledb/sm/array/array.h

@@ -589,10 +589,12 @@ class Array {
    * loaded before this function returns.
    *
    * @param enumeration_names The names of the enumerations.
+   * @param schema The ArraySchema to store loaded enumerations in.
    * @return std::vector<shared_ptr<const Enumeration>> The loaded enumerations.
    */
   std::vector<shared_ptr<const Enumeration>> get_enumerations(
-      const std::vector<std::string>& enumeration_names);
+      const std::vector<std::string>& enumeration_names,
+      shared_ptr<ArraySchema> schema);
 
   /** Load all enumerations for the array. */
   void load_all_enumerations();

tiledb/sm/array/array_directory.cc

@@ -123,7 +123,7 @@ shared_ptr<ArraySchema> ArrayDirectory::load_array_schema_latest(
   auto&& array_schema = load_array_schema_from_uri(
       resources_.get(), schema_uri, encryption_key, memory_tracker);
 
-  array_schema->set_array_uri(uri_);
+  array_schema->set_array_uri(uri_.remove_trailing_slash());
 
   return std::move(array_schema);
 }

tiledb/sm/c_api/tiledb.cc

@@ -3936,7 +3936,9 @@ capi_return_t tiledb_handle_load_enumerations_request(
       tiledb::sm::serialization::deserialize_load_enumerations_request(
           static_cast<tiledb::sm::SerializationType>(serialization_type),
           request->buffer());
-  auto enumerations = array->array_->get_enumerations(enumeration_names);
+  auto enumerations = array->array_->get_enumerations(
+      enumeration_names,
+      array->array_->opened_array()->array_schema_latest_ptr());
 
   tiledb::sm::serialization::serialize_load_enumerations_response(
       enumerations,

tiledb/sm/config/config.cc

@@ -91,7 +91,7 @@ const std::string Config::REST_RETRY_DELAY_FACTOR = "1.25";
 const std::string Config::REST_CURL_BUFFER_SIZE = "524288";
 const std::string Config::REST_CAPNP_TRAVERSAL_LIMIT = "2147483648";
 const std::string Config::REST_CURL_VERBOSE = "false";
-const std::string Config::REST_LOAD_ENUMERATIONS_ON_ARRAY_OPEN = "true";
+const std::string Config::REST_LOAD_ENUMERATIONS_ON_ARRAY_OPEN = "false";
 const std::string Config::REST_LOAD_METADATA_ON_ARRAY_OPEN = "true";
 const std::string Config::REST_LOAD_NON_EMPTY_DOMAIN_ON_ARRAY_OPEN = "true";
 const std::string Config::REST_USE_REFACTORED_ARRAY_OPEN = "true";