Change QueryType::WRITE_EXCLSUIVE to QueryType::MODIFY_EXCLSUIVE; tre…

…at as a WRITE

test/src/unit-cppapi-array.cc

@@ -687,7 +687,7 @@ TEST_CASE(
 TEST_CASE(
     "C++ API: Deletion of sequential fragment writes",
     "[cppapi][fragments][delete]") {
-  /* Note: An array must be open, in WRITE_EXCLUSIVE mode to delete_fragments */
+  /* Note: An array must be open in MODIFY_EXCLUSIVE mode to delete_fragments */
   Context ctx;
   VFS vfs(ctx);
   const std::string array_name = "cpp_unit_array";
@@ -718,14 +718,14 @@ TEST_CASE(
     CHECK(tiledb::test::num_fragments(array_name) == 3);
     REQUIRE_THROWS_WITH(
         array.delete_fragments(array_name, timestamp_start, timestamp_end),
-        Catch::Contains("Query type must be WRITE_EXCLUSIVE"));
+        Catch::Contains("Query type must be MODIFY_EXCLUSIVE"));
     CHECK(tiledb::test::num_fragments(array_name) == 3);
     array.close();
   }
 
-  SECTION("WRITE_EXCLUSIVE") {
-    auto array = tiledb::Array(ctx, array_name, TILEDB_WRITE_EXCLUSIVE);
-    auto query = tiledb::Query(ctx, array, TILEDB_WRITE_EXCLUSIVE);
+  SECTION("MODIFY_EXCLUSIVE") {
+    auto array = tiledb::Array(ctx, array_name, TILEDB_MODIFY_EXCLUSIVE);
+    auto query = tiledb::Query(ctx, array, TILEDB_MODIFY_EXCLUSIVE);
     query.set_data_buffer("a", data).set_subarray({0, 1}).submit();
     query.set_data_buffer("a", data).set_subarray({2, 3}).submit();
     query.set_data_buffer("a", data).set_subarray({4, 5}).submit();
@@ -745,7 +745,7 @@ TEST_CASE(
       // Consolidate and reopen array
       Array::consolidate(ctx, array_name);
       CHECK(tiledb::test::num_fragments(array_name) == 4);
-      array.open(TILEDB_WRITE_EXCLUSIVE);
+      array.open(TILEDB_MODIFY_EXCLUSIVE);
       CHECK(tiledb::test::num_fragments(array_name) == 4);
 
       // Check commits directory after consolidation

tiledb/sm/array/array.cc

@@ -226,10 +226,10 @@ Status Array::load_fragments(
 
 Status Array::delete_fragments(
     const URI& uri, uint64_t timestamp_start, uint64_t timestamp_end) {
-  // Check that query type is WRITE_EXCLUSIVE
-  if (query_type_ != QueryType::WRITE_EXCLUSIVE) {
+  // Check that query type is MODIFY_EXCLUSIVE
+  if (query_type_ != QueryType::MODIFY_EXCLUSIVE) {
     return LOG_STATUS(Status_ArrayError(
-        "[Array::delete_fragments] Query type must be WRITE_EXCLUSIVE"));
+        "[Array::delete_fragments] Query type must be MODIFY_EXCLUSIVE"));
   }
 
   // Check that array is open
@@ -349,7 +349,7 @@ Status Array::open(
         timestamp_end_opened_at_ = utils::time::timestamp_now_ms();
       } else if (
           query_type == QueryType::WRITE ||
-          query_type == QueryType::WRITE_EXCLUSIVE ||
+          query_type == QueryType::MODIFY_EXCLUSIVE ||
           query_type == QueryType::DELETE) {
         timestamp_end_opened_at_ = 0;
       } else {
@@ -455,7 +455,7 @@ Status Array::close() {
       // Update array metadata for write queries if metadata was written by the
       // user
       if ((query_type_ == QueryType::WRITE ||
-           query_type_ == QueryType::WRITE_EXCLUSIVE) &&
+           query_type_ == QueryType::MODIFY_EXCLUSIVE) &&
           metadata_.num() > 0) {
         // Set metadata loaded to be true so when serialization fetchs the
         // metadata it won't trigger a deadlock
@@ -480,7 +480,7 @@ Status Array::close() {
           throw StatusException(st);
       } else if (
           query_type_ == QueryType::WRITE ||
-          query_type_ == QueryType::WRITE_EXCLUSIVE) {
+          query_type_ == QueryType::MODIFY_EXCLUSIVE) {
         st = storage_manager_->array_close_for_writes(this);
         if (!st.ok())
           throw StatusException(st);
@@ -787,10 +787,10 @@ Status Array::delete_metadata(const char* key) {
 
   // Check mode
   if (query_type_ != QueryType::WRITE &&
-      query_type_ != QueryType::WRITE_EXCLUSIVE) {
+      query_type_ != QueryType::MODIFY_EXCLUSIVE) {
     return LOG_STATUS(
         Status_ArrayError("Cannot delete metadata. Array was "
-                          "not opened in write mode"));
+                          "not opened in write or modify_exclusive mode"));
   }
 
   // Check if key is null
@@ -817,10 +817,10 @@ Status Array::put_metadata(
 
   // Check mode
   if (query_type_ != QueryType::WRITE &&
-      query_type_ != QueryType::WRITE_EXCLUSIVE) {
+      query_type_ != QueryType::MODIFY_EXCLUSIVE) {
     return LOG_STATUS(
         Status_ArrayError("Cannot put metadata; Array was "
-                          "not opened in write mode"));
+                          "not opened in write or modify_exclusive mode"));
   }
 
   // Check if key is null

tiledb/sm/array/consistency.cc

@@ -71,16 +71,17 @@ ConsistencyController::entry_type ConsistencyController::register_array(
 
   std::lock_guard<std::mutex> lock(mtx_);
   if (this->is_open(uri)) {
-    if (query_type == QueryType::WRITE_EXCLUSIVE) {
+    if (query_type == QueryType::MODIFY_EXCLUSIVE) {
       throw std::runtime_error(
           "[ConsistencyController::register_array] Array already open; must "
-          "close array before opening for exclusive write.");
+          "close array before opening for exclusive modification.");
     } else {
       auto iter = array_registry_.find(uri);
-      if (iter->second.get_query_type() == QueryType::WRITE_EXCLUSIVE) {
+      if (iter->second.get_query_type() == QueryType::MODIFY_EXCLUSIVE) {
         throw std::runtime_error(
             "[ConsistencyController::register_array] Must close array opened "
-            "for exclusive write before opening an array at the same address.");
+            "for exclusive modification before opening an array at the same "
+            "address.");
       }
     }
   }

tiledb/sm/array/test/unit_consistency.cc

@@ -237,10 +237,10 @@ TEST_CASE(
 }
 
 TEST_CASE(
-    "WhiteboxConsistencyController: Exclusive write",
-    "[ConsistencyController][write][exclusive]") {
+    "WhiteboxConsistencyController: Exclusive modification",
+    "[ConsistencyController][modify][exclusive]") {
   WhiteboxConsistencyController x;
-  const URI uri = URI("whitebox_exclusive_write");
+  const URI uri = URI("whitebox_modify_exclusive");
 
   // Create a StorageManager
   Config config;
@@ -254,9 +254,9 @@ TEST_CASE(
   // Create an array
   tdb_unique_ptr<Array> array = x.create_array(uri, &sm);
 
-  // Open an array for exclusive write
+  // Open an array for exclusive modification
   st = array->open(
-      QueryType::WRITE_EXCLUSIVE, EncryptionType::NO_ENCRYPTION, nullptr, 0);
+      QueryType::MODIFY_EXCLUSIVE, EncryptionType::NO_ENCRYPTION, nullptr, 0);
   REQUIRE(st.ok());
   REQUIRE(x.registry_size() == 1);
   REQUIRE(x.is_open(uri) == true);
@@ -268,7 +268,7 @@ TEST_CASE(
   REQUIRE(x.registry_size() == 1);
   REQUIRE(x.is_open(uri) == true);
 
-  // Close exclusive write array
+  // Close exclusive modification array
   array.get()->close();
   REQUIRE(x.registry_size() == 0);
   REQUIRE(x.is_open(uri) == false);
@@ -279,10 +279,11 @@ TEST_CASE(
   REQUIRE(x.registry_size() == 1);
   REQUIRE(x.is_open(uri) == true);
 
-  // Try to register an array for exclusive write
+  // Try to register an array for exclusive modification
   REQUIRE_THROWS_WITH(
-      x.register_array(uri, *array, QueryType::WRITE_EXCLUSIVE),
-      Catch::Contains("must close array before opening for exclusive write"));
+      x.register_array(uri, *array, QueryType::MODIFY_EXCLUSIVE),
+      Catch::Contains(
+          "must close array before opening for exclusive modification"));
   REQUIRE(x.registry_size() == 1);
 
   // Clean up

tiledb/sm/c_api/tiledb_enum.h

@@ -37,8 +37,8 @@
     TILEDB_QUERY_TYPE_ENUM(WRITE) = 1,
     /** Delete query */
     TILEDB_QUERY_TYPE_ENUM(DELETE) = 2,
-    /** Exclusive Write query */
-    TILEDB_QUERY_TYPE_ENUM(WRITE_EXCLUSIVE) = 3,
+    /** Exclusive Modification query */
+    TILEDB_QUERY_TYPE_ENUM(MODIFY_EXCLUSIVE) = 3,
 #endif
 // clang-format on
 

tiledb/sm/cpp_api/query.h

@@ -2316,8 +2316,8 @@ class Query {
         return "READ";
       case TILEDB_WRITE:
         return "WRITE";
-      case TILEDB_WRITE_EXCLUSIVE:
-        return "WRITE_EXCLUSIVE";
+      case TILEDB_MODIFY_EXCLUSIVE:
+        return "MODIFY_EXCLUSIVE";
       case TILEDB_DELETE:
         return "DELETE";
     }

tiledb/sm/enums/query_type.h

@@ -55,10 +55,10 @@ inline const std::string& query_type_str(QueryType query_type) {
       return constants::query_type_read_str;
     case QueryType::WRITE:
       return constants::query_type_write_str;
-    case QueryType::WRITE_EXCLUSIVE:
-      return constants::query_type_write_exclusive_str;
     case QueryType::DELETE:
       return constants::query_type_delete_str;
+    case QueryType::MODIFY_EXCLUSIVE:
+      return constants::query_type_modify_exclusive_str;
     default:
       return constants::empty_str;
   }
@@ -71,10 +71,10 @@ inline Status query_type_enum(
     *query_type = QueryType::READ;
   else if (query_type_str == constants::query_type_write_str)
     *query_type = QueryType::WRITE;
-  else if (query_type_str == constants::query_type_write_exclusive_str)
-    *query_type = QueryType::WRITE_EXCLUSIVE;
   else if (query_type_str == constants::query_type_delete_str)
     *query_type = QueryType::DELETE;
+  else if (query_type_str == constants::query_type_modify_exclusive_str)
+    *query_type = QueryType::MODIFY_EXCLUSIVE;
   else {
     return Status_Error("Invalid QueryType " + query_type_str);
   }

tiledb/sm/group/group.cc

@@ -72,7 +72,7 @@ Status Group::open(
   }
 
   if (query_type != QueryType::READ && query_type != QueryType::WRITE &&
-      query_type != QueryType::WRITE_EXCLUSIVE) {
+      query_type != QueryType::MODIFY_EXCLUSIVE) {
     return Status_GroupError("Cannot open group; Unsupported query type");
   }
 
@@ -82,7 +82,7 @@ Status Group::open(
     } else {
       assert(
           query_type == QueryType::WRITE ||
-          query_type == QueryType::WRITE_EXCLUSIVE);
+          query_type == QueryType::MODIFY_EXCLUSIVE);
       timestamp_end = 0;
     }
   }
@@ -234,7 +234,7 @@ Status Group::close() {
     // Update group metadata for write queries if metadata was written by the
     // user
     if (query_type_ == QueryType::WRITE ||
-        query_type_ == QueryType::WRITE_EXCLUSIVE) {
+        query_type_ == QueryType::MODIFY_EXCLUSIVE) {
       if (metadata_.num() > 0) {
         // Set metadata loaded to be true so when serialization fetches the
         // metadata it won't trigger a deadlock
@@ -266,7 +266,7 @@ Status Group::close() {
       RETURN_NOT_OK(storage_manager_->group_close_for_reads(this));
     } else if (
         query_type_ == QueryType::WRITE ||
-        query_type_ == QueryType::WRITE_EXCLUSIVE) {
+        query_type_ == QueryType::MODIFY_EXCLUSIVE) {
       // If changes haven't been applied, apply them
       if (!changes_applied_) {
         RETURN_NOT_OK(apply_pending_changes());
@@ -309,10 +309,10 @@ Status Group::delete_metadata(const char* key) {
 
   // Check mode
   if (query_type_ != QueryType::WRITE &&
-      query_type_ != QueryType::WRITE_EXCLUSIVE)
+      query_type_ != QueryType::MODIFY_EXCLUSIVE)
     return Status_GroupError(
         "Cannot delete metadata. Group was "
-        "not opened in write mode");
+        "not opened in write or modify_exclusive mode");
 
   // Check if key is null
   if (key == nullptr)
@@ -334,10 +334,10 @@ Status Group::put_metadata(
 
   // Check mode
   if (query_type_ != QueryType::WRITE &&
-      query_type_ != QueryType::WRITE_EXCLUSIVE)
+      query_type_ != QueryType::MODIFY_EXCLUSIVE)
     return Status_GroupError(
         "Cannot put metadata; Group was "
-        "not opened in write mode");
+        "not opened in write or modify_exclusive mode");
 
   // Check if key is null
   if (key == nullptr)
@@ -527,9 +527,10 @@ Status Group::mark_member_for_addition(
 
   // Check mode
   if (query_type_ != QueryType::WRITE &&
-      query_type_ != QueryType::WRITE_EXCLUSIVE) {
+      query_type_ != QueryType::MODIFY_EXCLUSIVE) {
     return Status_GroupError(
-        "Cannot get member; Group was not opened in write mode");
+        "Cannot get member; Group was not opened in write or modify_exclusive "
+        "mode");
   }
 
   const std::string& uri = group_member_uri.to_string();
@@ -597,9 +598,10 @@ Status Group::mark_member_for_removal(const std::string& uri) {
 
   // Check mode
   if (query_type_ != QueryType::WRITE &&
-      query_type_ != QueryType::WRITE_EXCLUSIVE) {
+      query_type_ != QueryType::MODIFY_EXCLUSIVE) {
     return Status_GroupError(
-        "Cannot get member; Group was not opened in write mode");
+        "Cannot get member; Group was not opened in write or modify_exclusive "
+        "mode");
   }
   if (members_to_add_.find(uri) != members_to_add_.end()) {
     return Status_GroupError(

tiledb/sm/misc/constants.cc

@@ -281,12 +281,12 @@ const std::string query_type_read_str = "READ";
 /** TILEDB_WRITE Query String **/
 const std::string query_type_write_str = "WRITE";
 
-/** TILEDB_WRITE_EXCLUSIVE Query String **/
-const std::string query_type_write_exclusive_str = "WRITE_EXCLUSIVE";
-
 /** TILEDB_DELETE Query String **/
 const std::string query_type_delete_str = "DELETE";
 
+/** TILEDB_MODIFY_EXCLUSIVE Query String **/
+const std::string query_type_modify_exclusive_str = "MODIFY_EXCLUSIVE";
+
 /** TILEDB_FAILED Query String **/
 const std::string query_status_failed_str = "FAILED";
 

tiledb/sm/misc/constants.h

@@ -266,12 +266,12 @@ extern const std::string query_type_read_str;
 /** TILEDB_WRITE Query String **/
 extern const std::string query_type_write_str;
 
-/** TILEDB_WRITE_EXCLUSIVE Query String **/
-extern const std::string query_type_write_exclusive_str;
-
 /** TILEDB_DELETE Query String **/
 extern const std::string query_type_delete_str;
 
+/** TILEDB_MODIFY_EXCLUSIVE Query String **/
+extern const std::string query_type_modify_exclusive_str;
+
 /** TILEDB_FAILED Query String **/
 extern const std::string query_status_failed_str;