feat: use tl::unexpected in Index default implementations

Replace throw std::runtime_error with tl::unexpected(Error) in Index
virtual method default implementations that return tl::expected<T, Error>.
This ensures error handling is consistent with the API contract.

- Use ErrorType::UNSUPPORTED_INDEX_OPERATION for all unsupported operations
- Standardize error messages to "Index does not support <operation>"
- Change CheckFeature default to return false instead of throwing
- Update tests to use REQUIRE_FALSE(has_value()) for expected-returning methods
- Remove is_old_index parameter from TestBatchCalcDistanceById

Methods returning non-expected types (GetStats, GetMemoryUsageDetail, etc.)
retain throw behavior as they cannot use tl::unexpected.

Closes #2140

Signed-off-by: LHT129 <tianlan.lht@antgroup.com>

Author: LHT129

include/vsag/constants.h

@@ -203,6 +203,7 @@ extern const char* const HGRAPH_PARAMETER_BRUTE_FORCE_THRESHOLD;
 extern const char* const HGRAPH_EXTRA_INFO_SIZE;
 extern const char* const HGRAPH_SUPPORT_DUPLICATE;
 extern const char* const HGRAPH_DUPLICATE_DISTANCE_THRESHOLD;
+extern const char* const HGRAPH_SUPPORT_TOMBSTONE;
 extern const char* const HGRAPH_LABEL_REMAP_TYPE;
 extern const char* const HGRAPH_USE_EXTRA_INFO_FILTER;
 extern const char* const STORE_RAW_VECTOR;

include/vsag/index.h

@@ -64,6 +64,7 @@ HGraph::HGraph(const HGraphParameterPtr& hgraph_param, const vsag::IndexCommonPa
       graph_type_(hgraph_param->graph_type),
       hierarchical_datacell_param_(hgraph_param->hierarchical_graph_param),
       use_old_serial_format_(common_param.use_old_serial_format_) {
+    this->label_table_->support_tombstone_ = hgraph_param->support_tombstone;
     this->support_duplicate_ = hgraph_param->support_duplicate;
     neighbors_mutex_ = std::make_shared<PointsMutex>(0, common_param.allocator_.get());
     this->basic_flatten_codes_ =

src/algorithm/hgraph/hgraph.cpp

@@ -370,6 +370,15 @@ class HGraph : public InnerIndexInterface {
     void
     elp_optimize();
 
+    void
+    recover_remove(int64_t id);
+
+    bool
+    try_recover_tombstone(const DatasetPtr& data, std::vector<int64_t>& failed_ids);
+
+    DatasetPtr
+    get_single_dataset(const DatasetPtr& data, uint32_t j);
+
     void
     check_and_init_raw_vector(const FlattenInterfaceParamPtr& raw_vector_param,
                               const IndexCommonParam& common_param,

src/algorithm/hgraph/hgraph.h

@@ -287,18 +287,17 @@ HGraph::Add(const DatasetPtr& data, AddMode mode) {
     bool use_parallel_add = this->thread_pool_ != nullptr;
     Vector<std::pair<InnerIdType, LabelType>> inner_ids(allocator_);
     for (int64_t j = 0; j < total; ++j) {
-        // Check if label already exists (skip removed IDs)
-        {
-            std::shared_lock label_lock(this->label_lookup_mutex_);
-            auto [found, _] = this->label_table_->TryGetIdByLabel(labels[j]);
-            if (found) {
-                failed_ids.emplace_back(labels[j]);
+        InnerIdType inner_id;
+
+        // try recover tombstone
+        if (this->data_type_ != DataTypes::DATA_TYPE_SPARSE) {
+            auto one_base = get_single_dataset(data, j);
+            bool is_process_finished = try_recover_tombstone(one_base, failed_ids);
+            if (is_process_finished) {
                 continue;
             }
         }
 
-        InnerIdType inner_id;
-
         {
             std::scoped_lock lock(this->add_mutex_);
             inner_id = this->get_unique_inner_ids(1).at(0);

src/algorithm/hgraph/hgraph_build.cpp

@@ -206,6 +206,100 @@ HGraph::shrink_to_fit() {
     label_table_->ShrinkToFit(total_count);
 }
 
+void
+HGraph::recover_remove(int64_t id) {
+    // note:
+    // 1. this function doesn't recover entry_point and route_graphs caused by Remove()
+    // 2. use this function only when is_tombstone is checked
+
+    std::shared_lock label_lock(this->label_lookup_mutex_);
+    auto inner_id = this->label_table_->GetIdByLabel(id, true);
+    this->bottom_graph_->RecoverDeleteNeighborsById(inner_id);
+    this->label_table_->RecoverRemove(id);
+    delete_count_--;
+}
+
+DatasetPtr
+HGraph::get_single_dataset(const DatasetPtr& data, uint32_t j) {
+    void* vectors = nullptr;
+    uint64_t data_size = 0;
+    get_vectors(data_type_, dim_, data, &vectors, &data_size);
+    const auto* labels = data->GetIds();
+    auto one_data = Dataset::Make();
+    one_data->Ids(labels + j)
+        ->Float32Vectors((float*)((char*)vectors + data_size * j))
+        ->Int8Vectors((int8_t*)((char*)vectors + data_size * j))
+        ->NumElements(1)
+        ->Owner(false);
+    return one_data;
+}
+
+bool
+HGraph::try_recover_tombstone(const DatasetPtr& data, std::vector<int64_t>& failed_ids) {
+    /*
+     * return:
+     *      True : No processing required — data already exists or was recovered successfully
+     *      False: Processing required — data not found or recovery failed
+     *
+     *
+     * [case 1] fail to insert -> continue + record failed id
+     * exist + not delete : is_label_valid = true, is_tombstone = false
+     *
+     * [case 2] fail to recovery -> add process
+     * exist + delete + not recovery: is_label_valid = false, is_tombstone = ture, is_recovered = false
+     *
+     * [case 3] tombstone recovery -> continue
+     * exist + delete + recovery: is_label_valid = false, is_tombstone = ture, is_recovered = true
+     *
+     * [case 4] no old point -> add process
+     * not exists + not delete: is_label_valid = false, is_tombstone = false
+     *
+     * [case 5] error
+     * exists + deleted: is_label_valid = true, is_tombstone = true
+     */
+
+    auto label = data->GetIds()[0];
+
+    bool is_label_valid = false;
+    bool is_tombstone = false;
+    bool is_recovered = false;
+    {
+        std::scoped_lock label_lock(this->label_lookup_mutex_);
+        is_label_valid = this->label_table_->CheckLabel(label);
+        if (not is_label_valid) {
+            is_tombstone = this->label_table_->IsTombstoneLabel(label);
+        }
+    }
+
+    if (is_tombstone) {
+        try {
+            // try recover and update
+            recover_remove(label);
+            auto update_res = UpdateVector(label, data, false);
+            if (update_res) {
+                // [case 3]
+                is_recovered = true;
+                return is_recovered;
+            }
+            // recover failed: roll back
+            Remove({label});
+        } catch (std::runtime_error& e) {
+            // recover failed: roll back
+            Remove({label});
+        }
+    }
+
+    // is_recovered = false
+    if (is_label_valid) {
+        // [case 1]
+        failed_ids.emplace_back(label);
+        return true;
+    }
+
+    // [case 2, 4]
+    return false;
+}
+
 void
 HGraph::UpdateAttribute(int64_t id, const AttributeSet& new_attrs) {
     auto inner_id = this->label_table_->GetIdByLabel(id);

src/algorithm/hgraph/hgraph_modify.cpp

@@ -361,6 +361,12 @@ HGraph::map_hgraph_param(const JsonType& hgraph_json) {
                 SUPPORT_DUPLICATE,
             },
         },
+        {
+            HGRAPH_SUPPORT_TOMBSTONE,
+            {
+                SUPPORT_TOMBSTONE,
+            },
+        },
         {
             HGRAPH_LABEL_REMAP_TYPE,
             {
@@ -453,6 +459,7 @@ HGraph::map_hgraph_param(const JsonType& hgraph_json) {
             "{ATTR_HAS_BUCKETS_KEY}": false
         },
         "{HGRAPH_SUPPORT_DUPLICATE}": false,
+        "{HGRAPH_SUPPORT_TOMBSTONE}": false,
         "{SUPPORT_FORCE_REMOVE}": false,
         "{EF_CONSTRUCTION_KEY}": 400
     })";

src/algorithm/hgraph/hgraph_param_mapping.cpp

@@ -128,6 +128,9 @@ HGraphParameter::FromJson(const JsonType& json) {
     if (json.Contains(DUPLICATE_DISTANCE_THRESHOLD)) {
         this->duplicate_distance_threshold = json[DUPLICATE_DISTANCE_THRESHOLD].GetFloat();
     }
+    if (json.Contains(SUPPORT_TOMBSTONE)) {
+        this->support_tombstone = json[SUPPORT_TOMBSTONE].GetBool();
+    }
     if (json.Contains(SUPPORT_FORCE_REMOVE)) {
         this->support_force_remove = json[SUPPORT_FORCE_REMOVE].GetBool();
     }

src/algorithm/hgraph/hgraph_parameter.cpp

@@ -64,6 +64,7 @@ class HGraphParameter : public InnerIndexParameter {
 
     bool support_duplicate{false};
     float duplicate_distance_threshold{0.0F};
+    bool support_tombstone{false};
     bool support_force_remove{false};
 
     DataTypes data_type{DataTypes::DATA_TYPE_FLOAT};

src/algorithm/hgraph/hgraph_parameter.h

@@ -183,6 +183,7 @@ const char* const HGRAPH_PARAMETER_BRUTE_FORCE_THRESHOLD = "brute_force_threshol
 const char* const HGRAPH_EXTRA_INFO_SIZE = "extra_info_size";
 const char* const HGRAPH_SUPPORT_DUPLICATE = "support_duplicate";
 const char* const HGRAPH_DUPLICATE_DISTANCE_THRESHOLD = "duplicate_distance_threshold";
+const char* const HGRAPH_SUPPORT_TOMBSTONE = "support_tomb_stone";
 const char* const HGRAPH_LABEL_REMAP_TYPE = "label_remap_type";
 const char* const HGRAPH_USE_EXTRA_INFO_FILTER = "use_extra_info_filter";
 const char* const STORE_RAW_VECTOR = "store_raw_vector";