Fix opening arrays with unrecognized files in their root directory et al. (#5474)

[SC-64121](https://app.shortcut.com/tiledb-inc/story/64121/cannot-open-array-with-unrecognized-files-in-its-root-directory)

This PR updates `ArrayDirectory::is_fragment` to return a negative
result if the file's name is not a fragment identifier, instead of
throwing and failing the open.

I also did a small clean-up of the `FragmentID` class.

---
TYPE: BUG
DESC: Fixed opening arrays with unrecognized files in their root
directory.

Author: teo-tsirpanis

test/regression/CMakeLists.txt

@@ -57,6 +57,7 @@ if (TILEDB_CPP_API)
   list(APPEND SOURCES targets/sc-53791.cc)
   list(APPEND SOURCES targets/sc-53970.cc)
   list(APPEND SOURCES targets/sc-54473.cc)
+  list(APPEND SOURCES targets/sc-64121.cc)
 endif()
 
 add_executable(tiledb_regression

test/regression/targets/sc-64121.cc

@@ -0,0 +1,54 @@
+/**
+ * @file   sc-64121.cc
+ *
+ * @section LICENSE
+ *
+ * The MIT License
+ *
+ * @copyright Copyright (c) 2025 TileDB, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <tiledb/tiledb>
+
+#include <test/support/tdb_catch.h>
+
+using namespace tiledb;
+
+TEST_CASE(
+    "SC-64121 open array with unrecognized files",
+    "[regression][bug][sc-64121]") {
+  Context ctx;
+
+  std::string uri("sc-64121");
+
+  ArraySchema schema(ctx, TILEDB_SPARSE);
+  Domain domain(ctx);
+  domain.add_dimension(Dimension::create<uint64_t>(ctx, "x", {{1, 100}}, 10));
+  schema.set_domain(domain);
+  schema.add_attribute(Attribute(ctx, "a", TILEDB_UINT64));
+  Array::create(uri, schema);
+
+  VFS vfs(ctx);
+  vfs.touch(uri + "/data.bin");
+
+  REQUIRE_NOTHROW(Array(ctx, uri, TILEDB_READ));
+}

tiledb/sm/array/array_directory.cc

@@ -1258,9 +1258,15 @@ Status ArrayDirectory::is_fragment(
     const std::unordered_set<std::string>& ok_uris_set,
     const std::unordered_set<std::string>& consolidated_uris_set,
     int* is_fragment) const {
-  // If the URI name has a suffix, then it is not a fragment
+  // If the fragment ID does not have a name, ignore it.
+  if (!FragmentID::has_fragment_name(uri)) {
+    *is_fragment = 0;
+    return Status::Ok();
+  }
+
   FragmentID fragment_id{uri};
   auto name = fragment_id.name();
+  // If the URI name has a suffix, then it is not a fragment
   if (name.find_first_of('.') != std::string::npos) {
     *is_fragment = 0;
     return Status::Ok();

tiledb/sm/fragment/fragment_identifier.cc

@@ -54,8 +54,7 @@ class InvalidURIException : public FragmentIDException {
 };
 
 FragmentID::FragmentID(const URI& uri)
-    : URI(uri)
-    , name_(uri.remove_trailing_slash().last_path_part())
+    : name_(uri.remove_trailing_slash().last_path_part())
     , timestamp_range_({0, 0})
     , name_version_(FragmentNameVersion::ONE) {
   // Ensure input uri is valid (non-empty)
@@ -88,19 +87,18 @@ FragmentID::FragmentID(const URI& uri)
     array_format_version_ = 2;
     sscanf(
         array_format_version_str.c_str(),
-        (std::string("%") + std::string(PRId64)).c_str(),
-        (long long int*)&timestamp_range_.first);
+        "%" PRId64,
+        (int64_t*)&timestamp_range_.first);
     timestamp_range_.second = timestamp_range_.first;
   } else {
     if (name_version_ == FragmentNameVersion::TWO) {
       array_format_version_ = 4;
     }
     sscanf(
         name_.c_str(),
-        (std::string("__%") + std::string(PRId64) + "_%" + std::string(PRId64))
-            .c_str(),
-        (long long int*)&timestamp_range_.first,
-        (long long int*)&timestamp_range_.second);
+        "__%" PRId64 "_%" PRId64,
+        (int64_t*)&timestamp_range_.first,
+        (int64_t*)&timestamp_range_.second);
   }
   if (timestamp_range_.first > timestamp_range_.second) {
     throw FragmentIDException(
@@ -109,6 +107,19 @@ FragmentID::FragmentID(const URI& uri)
   }
 }
 
+bool FragmentID::has_fragment_name(const URI& uri) {
+  if (uri.empty()) {
+    throw InvalidURIException("URI may not be empty.");
+  }
+
+  auto name = uri.remove_trailing_slash().last_path_part();
+  auto pos = name.find_last_of('.');
+  if (pos != std::string::npos) {
+    name = name.substr(0, pos);
+  }
+  return name.find_last_of('_') != std::string::npos;
+}
+
 FragmentID::FragmentID(const std::string_view& path)
     : FragmentID(URI(path)) {
 }

tiledb/sm/fragment/fragment_identifier.h

@@ -70,7 +70,7 @@ enum class FragmentNameVersion { ONE, TWO, THREE };
  * Trailing "_".
  * Otherwise potentially-malformed names, which may not begin with "__".
  */
-class FragmentID : private URI {
+class FragmentID {
  private:
   /**
    * Whitebox testing class provides additional accessors to components of the
@@ -99,6 +99,11 @@ class FragmentID : private URI {
   /** Destructor. */
   ~FragmentID() = default;
 
+  /**
+   * Returns whether a URI contains a fragment name.
+   */
+  static bool has_fragment_name(const URI& uri);
+
   /** Accessor to the fragment name. */
   inline const std::string& name() const {
     return name_;

tiledb/sm/fragment/test/unit_fragment_identifier.cc

@@ -268,3 +268,15 @@ TEST_CASE("FragmentID: Valid uris", "[fragment_id][valid_uri]") {
     }
   }
 }
+
+TEST_CASE("FragmentID: has_fragment_name", "[fragment_id][has_fragment_name]") {
+  CHECK(
+      FragmentID::has_fragment_name(URI("__0123456789ABCDEF0123456789ABCDEF")));
+  CHECK_THROWS(FragmentID::has_fragment_name(URI("")));
+  CHECK_FALSE(
+      FragmentID::has_fragment_name(URI("0123456789ABCDEF0123456789ABCDEF")));
+  CHECK_FALSE(FragmentID::has_fragment_name(
+      URI("__directory/0123456789ABCDEF0123456789ABCDEF")));
+  CHECK_FALSE(FragmentID::has_fragment_name(
+      URI("0123456789ABCDEF0123456789ABCDEF.__ext")));
+}