Array schema load changes.

Author: shaunrd0

tiledb/sm/array_schema/array_schema_operations.cc

@@ -36,8 +36,12 @@
 #include "tiledb/sm/array_schema/dimension_label.h"
 #include "tiledb/sm/array_schema/domain.h"
 #include "tiledb/sm/array_schema/enumeration.h"
+#include "tiledb/sm/config/config.h"
+#include "tiledb/sm/crypto/encryption_key.h"
 #include "tiledb/sm/filesystem/uri.h"
 #include "tiledb/sm/misc/integral_type_casts.h"
+#include "tiledb/sm/rest/rest_client.h"
+#include "tiledb/sm/storage_manager/context.h"
 #include "tiledb/sm/storage_manager/context_resources.h"
 #include "tiledb/sm/tile/generic_tile_io.h"
 #include "tiledb/sm/tile/tile.h"
@@ -227,4 +231,61 @@ void store_array_schema(
   }
 }
 
+shared_ptr<ArraySchema> load_array_schema(
+    const Context& ctx, const URI& uri, const Config& config) {
+  // Check array name
+  if (uri.is_invalid()) {
+    throw std::runtime_error("Failed to load array schema; Invalid array URI");
+  }
+
+  if (uri.is_tiledb()) {
+    auto& rest_client = ctx.rest_client();
+    auto&& [st, array_schema_response] =
+        rest_client.get_array_schema_from_rest(uri);
+    throw_if_not_ok(st);
+    return std::move(array_schema_response.value());
+  } else {
+    // Create key
+    tiledb::sm::EncryptionKey key;
+    throw_if_not_ok(
+        key.set_key(tiledb::sm::EncryptionType::NO_ENCRYPTION, nullptr, 0));
+
+    // Load URIs from the array directory
+    optional<tiledb::sm::ArrayDirectory> array_dir;
+    array_dir.emplace(
+        ctx.resources(),
+        uri,
+        0,
+        UINT64_MAX,
+        tiledb::sm::ArrayDirectoryMode::SCHEMA_ONLY);
+
+    auto tracker = ctx.resources().ephemeral_memory_tracker();
+    // Load latest array schema
+    auto&& array_schema_latest =
+        array_dir->load_array_schema_latest(key, tracker);
+
+    // Load enumerations if config option is set.
+    bool incl_enums = config.get<bool>(
+        "rest.load_enumerations_on_array_open", Config::must_find);
+    if (incl_enums) {
+      std::vector<std::string> enmr_paths_to_load;
+      auto enmr_names = array_schema_latest->get_enumeration_names();
+      for (auto& name : enmr_names) {
+        if (!array_schema_latest->is_enumeration_loaded(name)) {
+          auto& path = array_schema_latest->get_enumeration_path_name(name);
+          enmr_paths_to_load.emplace_back(path);
+        }
+      }
+
+      auto enmrs_loaded = array_dir->load_enumerations_from_paths(
+          enmr_paths_to_load, key, tracker);
+      for (auto& enmr : enmrs_loaded) {
+        array_schema_latest->store_enumeration(enmr);
+      }
+    }
+
+    return std::move(array_schema_latest);
+  }
+}
+
 }  // namespace tiledb::sm

tiledb/sm/array_schema/array_schema_operations.h

@@ -41,8 +41,11 @@ using namespace tiledb::common;
 namespace tiledb::sm {
 
 class ArraySchema;
+class Config;
+class Context;
 class ContextResources;
 class EncryptionKey;
+class URI;
 
 /* ********************************* */
 /*                API                */
@@ -76,6 +79,16 @@ void store_array_schema(
     const shared_ptr<ArraySchema>& array_schema,
     const EncryptionKey& encryption_key);
 
+/**
+ * Handles loading an array schema from a URI.
+ *
+ * @param ctx TileDB Context.
+ * @param uri The URI of the array to load schema.
+ * @param config TileDB Config. If null, the context config will be used.
+ */
+shared_ptr<ArraySchema> load_array_schema(
+    const Context& ctx, const URI& uri, const Config& config);
+
 }  // namespace tiledb::sm
 
 #endif  // TILEDB_ARRAY_SCHEMA_OPERATIONS_H

tiledb/sm/c_api/tiledb.cc

@@ -56,6 +56,7 @@
 #include "tiledb/common/memory_tracker.h"
 #include "tiledb/sm/array/array.h"
 #include "tiledb/sm/array_schema/array_schema.h"
+#include "tiledb/sm/array_schema/array_schema_operations.h"
 #include "tiledb/sm/array_schema/dimension_label.h"
 #include "tiledb/sm/c_api/api_argument_validator.h"
 #include "tiledb/sm/config/config.h"
@@ -455,64 +456,51 @@ int32_t tiledb_array_schema_load(
     const char* array_uri,
     tiledb_array_schema_t** array_schema) {
   // Create array schema
+  ensure_context_is_valid(ctx);
+  ensure_output_pointer_is_valid(array_schema);
   *array_schema = new (std::nothrow) tiledb_array_schema_t;
   if (*array_schema == nullptr) {
-    auto st = Status_Error("Failed to allocate TileDB array schema object");
-    LOG_STATUS_NO_RETURN_VALUE(st);
-    save_error(ctx, st);
-    return TILEDB_OOM;
+    throw CAPIStatusException("Failed to allocate TileDB array schema object");
   }
 
-  // Check array name
-  tiledb::sm::URI uri(array_uri);
-  if (uri.is_invalid()) {
-    auto st = Status_Error("Failed to load array schema; Invalid array URI");
-    LOG_STATUS_NO_RETURN_VALUE(st);
-    save_error(ctx, st);
-    return TILEDB_ERR;
+  try {
+    // Use a default constructed config to load the schema with default options.
+    (*array_schema)->array_schema_ =
+        load_array_schema(ctx->context(), sm::URI(array_uri), sm::Config());
+  } catch (...) {
+    delete *array_schema;
+    throw;
   }
 
-  if (uri.is_tiledb()) {
-    auto& rest_client = ctx->context().rest_client();
-    auto&& [st, array_schema_rest] =
-        rest_client.get_array_schema_from_rest(uri);
-    if (!st.ok()) {
-      LOG_STATUS_NO_RETURN_VALUE(st);
-      save_error(ctx, st);
-      delete *array_schema;
-      return TILEDB_ERR;
-    }
-    (*array_schema)->array_schema_ = array_schema_rest.value();
-  } else {
-    // Create key
-    tiledb::sm::EncryptionKey key;
-    throw_if_not_ok(
-        key.set_key(tiledb::sm::EncryptionType::NO_ENCRYPTION, nullptr, 0));
+  return TILEDB_OK;
+}
 
-    // Load URIs from the array directory
-    optional<tiledb::sm::ArrayDirectory> array_dir;
-    try {
-      array_dir.emplace(
-          ctx->resources(),
-          uri,
-          0,
-          UINT64_MAX,
-          tiledb::sm::ArrayDirectoryMode::SCHEMA_ONLY);
-    } catch (const std::logic_error& le) {
-      auto st = Status_ArrayDirectoryError(le.what());
-      LOG_STATUS_NO_RETURN_VALUE(st);
-      save_error(ctx, st);
-      delete *array_schema;
-      return TILEDB_ERR;
-    }
+int32_t tiledb_array_schema_load_with_options(
+    tiledb_ctx_t* ctx,
+    tiledb_config_t* config,
+    const char* array_uri,
+    tiledb_array_schema_t** array_schema) {
+  ensure_context_is_valid(ctx);
+  ensure_config_is_valid(config);
+  ensure_output_pointer_is_valid(array_schema);
 
-    auto tracker = ctx->resources().ephemeral_memory_tracker();
+  // Create array schema
+  *array_schema = new (std::nothrow) tiledb_array_schema_t;
+  if (*array_schema == nullptr) {
+    throw CAPIStatusException("Failed to allocate TileDB array schema object");
+  }
 
-    // Load latest array schema
-    auto&& array_schema_latest =
-        array_dir->load_array_schema_latest(key, tracker);
-    (*array_schema)->array_schema_ = array_schema_latest;
+  try {
+    // Use passed config or context config to load the schema with set options.
+    (*array_schema)->array_schema_ = load_array_schema(
+        ctx->context(),
+        sm::URI(array_uri),
+        config ? config->config() : ctx->config());
+  } catch (...) {
+    delete *array_schema;
+    throw;
   }
+
   return TILEDB_OK;
 }
 
@@ -5011,6 +4999,16 @@ CAPI_INTERFACE(
       ctx, array_uri, array_schema);
 }
 
+CAPI_INTERFACE(
+    array_schema_load_with_options,
+    tiledb_ctx_t* ctx,
+    tiledb_config_t* config,
+    const char* array_uri,
+    tiledb_array_schema_t** array_schema) {
+  return api_entry<tiledb::api::tiledb_array_schema_load_with_options>(
+      ctx, config, array_uri, array_schema);
+}
+
 CAPI_INTERFACE(
     array_schema_get_array_type,
     tiledb_ctx_t* ctx,

tiledb/sm/c_api/tiledb.h

@@ -604,7 +604,7 @@ TILEDB_EXPORT int32_t tiledb_array_schema_check(
 
 /**
  * Retrieves the schema of an array from the disk, creating an array schema
- * struct.
+ * struct. The schema retrieved will always be the latest schema for the array.
  *
  * **Example:**
  *
@@ -624,6 +624,39 @@ TILEDB_EXPORT int32_t tiledb_array_schema_load(
     const char* array_uri,
     tiledb_array_schema_t** array_schema) TILEDB_NOEXCEPT;
 
+/**
+ * Retrieves the schema of an array, creating an array schema struct. Options to
+ * load additional features are read from the provided tiledb_config_t*
+ * instance. If the provided config is nullptr, the config from `ctx` is used
+ * instead.
+ *
+ * Currently supported options to be read from the config:
+ *  - rest.load_enumerations_on_array_open - boolean
+ *
+ * **Example:**
+ *
+ * @code{.c}
+ * tiledb_array_schema_t* array_schema;
+ * tiledb_array_schema_load_with_options(
+ *     ctx,
+ *     config,
+ *     "s3://tiledb_bucket/my_array",
+ *     &array_schema);
+ * // Make sure to free the array schema in the end
+ * @endcode
+ *
+ * @param ctx The TileDB context.
+ * @param config The TileDB config.
+ * @param array_uri The array whose schema will be retrieved.
+ * @param array_schema The array schema to be retrieved, or `NULL` upon error.
+ * @return `TILEDB_OK` for success and `TILEDB_OOM` or `TILEDB_ERR` for error.
+ */
+TILEDB_EXPORT int32_t tiledb_array_schema_load_with_options(
+    tiledb_ctx_t* ctx,
+    tiledb_config_t* config,
+    const char* array_uri,
+    tiledb_array_schema_t** array_schema) TILEDB_NOEXCEPT;
+
 /**
  * Retrieves the array type.
  *