Validate open array paths for TILEDB_EXPERIMENTAL

- Fix syntax error
- Use constexpr to check if experimental features are enabled
- Syntax changes

test/src/unit-backwards_compat.cc

@@ -684,6 +684,10 @@ TEST_CASE(
 TEST_CASE(
     "Backwards compatibility: Write to an array of older version",
     "[backwards-compat][write-to-older-version]") {
+  if constexpr (is_experimental_build) {
+    return;
+  }
+
   std::string old_array_name(arrays_dir + "/non_split_coords_v1_4_0");
   Context ctx;
   std::string fragment_uri;

test/src/unit-capi-consolidation.cc

@@ -6737,6 +6737,10 @@ TEST_CASE_METHOD(
     ConsolidationFx,
     "C API: Test consolidation, sparse, commits, mixed versions",
     "[capi][consolidation][commits][mixed-versions]") {
+  if constexpr (is_experimental_build) {
+    return;
+  }
+
   remove_sparse_array();
 
   // Get the v11 sparse array.

test/src/unit-cppapi-consolidation-with-timestamps.cc

@@ -518,6 +518,10 @@ TEST_CASE_METHOD(
     "CPP API: Test consolidation with timestamps, check directory contents of "
     "old array",
     "[cppapi][consolidation-with-timestamps][sparse-unordered-with-dups]") {
+  if constexpr (is_experimental_build) {
+    return;
+  }
+
   remove_sparse_array();
   create_sparse_array_v11();
   // Write first fragment.

tiledb/common/common.h

@@ -54,7 +54,6 @@ namespace tdb = tiledb::common;
 using std::shared_ptr;
 using tiledb::common::allocator;
 using tiledb::common::make_shared;
-// using tiledb::common::make_unique;
 
 /*
  * Exception
@@ -65,4 +64,13 @@ using tiledb::common::make_shared;
 using tiledb::common::StatusException;
 using tiledb::common::throw_if_not_ok;
 
+/*
+ * Experimental build
+ */
+#ifdef TILEDB_EXPERIMENTAL_FEATURES
+constexpr bool is_experimental_build = true;
+#else
+constexpr bool is_experimental_build = false;
+#endif  // TILEDB_EXPERIMENTAL_FEATURES
+
 #endif  // TILEDB_COMMON_COMMON_H

tiledb/sm/storage_manager/storage_manager.cc

@@ -251,6 +251,23 @@ StorageManager::array_open_for_reads(Array* array) {
           *array->encryption_key());
   RETURN_NOT_OK_TUPLE(st, nullopt, nullopt, nullopt);
 
+  // If building experimentally, this library should not be able to
+  // read from newer-versioned arrays
+  if constexpr (is_experimental_build) {
+    auto version = array_schema_latest.value()->version();
+    if (version > constants::format_version) {
+      std::stringstream err;
+      err << "Cannot open array for reads; Array format version (";
+      err << version;
+      err << ") is newer than library format version (";
+      err << constants::format_version << ")";
+      return {logger_->status(Status_StorageManagerError(err.str())),
+              nullopt,
+              nullopt,
+              nullopt};
+    }
+  }
+
   // Mark the array as open
   std::lock_guard<std::mutex> lock{open_arrays_mtx_};
   open_arrays_.insert(array);
@@ -272,6 +289,22 @@ StorageManager::array_open_for_reads_without_fragments(Array* array) {
       load_array_schemas(array->array_directory(), *array->encryption_key());
   RETURN_NOT_OK_TUPLE(st_schemas, nullopt, nullopt);
 
+  // If building experimentally, this library should not be able to
+  // read from newer-versioned arrays
+  if constexpr (is_experimental_build) {
+    auto version = array_schema_latest.value()->version();
+    if (version > constants::format_version) {
+      std::stringstream err;
+      err << "Cannot open array for reads; Array format version (";
+      err << version;
+      err << ") is newer than library format version (";
+      err << constants::format_version << ")";
+      return {logger_->status(Status_StorageManagerError(err.str())),
+              nullopt,
+              nullopt};
+    }
+  }
+
   // Mark the array as now open
   std::lock_guard<std::mutex> lock{open_arrays_mtx_};
   open_arrays_.insert(array);
@@ -296,9 +329,23 @@ StorageManager::array_open_for_writes(Array* array) {
       load_array_schemas(array->array_directory(), *array->encryption_key());
   RETURN_NOT_OK_TUPLE(st_schemas, nullopt, nullopt);
 
-  // This library should not be able to write to newer-versioned arrays
+  // If building experimentally, this library should not be able to
+  // write to newer-versioned or older-versioned arrays
+  // Else, this library should not be able to write to newer-versioned arrays
   // (but it is ok to write to older arrays)
   auto version = array_schema_latest.value()->version();
+  if constexpr (is_experimental_build) {
+    if (version != constants::format_version) {
+      std::stringstream err;
+      err << "Cannot open array for writes; Array format version (";
+      err << version;
+      err << ") is not the library format version (";
+      err << constants::format_version << ")";
+      return {logger_->status(Status_StorageManagerError(err.str())),
+              nullopt,
+              nullopt};
+    }
+  }
   if (version > constants::format_version) {
     std::stringstream err;
     err << "Cannot open array for writes; Array format version (";