fix(search): drop index DD option added

Author: vyavdoshenko

src/server/search/doc_index.cc

@@ -242,6 +242,19 @@ size_t ShardDocIndex::DocKeyIndex::Size() const {
   return ids_.size();
 }
 
+std::vector<std::string> ShardDocIndex::DocKeyIndex::GetAllKeys() const {
+  std::vector<std::string> keys;
+  keys.reserve(ids_.size());
+
+  for (const auto& [key, id] : ids_) {
+    if (!key.empty()) {
+      keys.push_back(key);
+    }
+  }
+
+  return keys;
+}
+
 uint8_t DocIndex::GetObjCode() const {
   return type == JSON ? OBJ_JSON : OBJ_HASH;
 }
@@ -607,6 +620,10 @@ DocIndexInfo ShardDocIndex::GetInfo() const {
   return {*base_, key_index_.Size()};
 }
 
+std::vector<std::string> ShardDocIndex::GetAllKeys() const {
+  return key_index_.GetAllKeys();
+}
+
 io::Result<StringVec, ErrorReply> ShardDocIndex::GetTagVals(string_view field) const {
   search::BaseIndex* base_index = indices_->GetIndex(field);
   if (base_index == nullptr) {

src/server/search/doc_index.h

@@ -224,6 +224,9 @@ class ShardDocIndex {
     std::string_view Get(DocId id) const;
     size_t Size() const;
 
+    // Get all keys in the index
+    std::vector<std::string> GetAllKeys() const;
+
    private:
     absl::flat_hash_map<std::string, DocId> ids_;
     std::vector<std::string> keys_;
@@ -262,6 +265,9 @@ class ShardDocIndex {
 
   DocIndexInfo GetInfo() const;
 
+  // Get all document keys in this index
+  std::vector<std::string> GetAllKeys() const;
+
   io::Result<StringVec, facade::ErrorReply> GetTagVals(std::string_view field) const;
 
   // Get synonym manager for this shard

src/server/search/search_family.cc

@@ -1131,18 +1131,60 @@ void SearchFamily::FtAlter(CmdArgList args, const CommandContext& cmd_cntx) {
 
 void SearchFamily::FtDropIndex(CmdArgList args, const CommandContext& cmd_cntx) {
   string_view idx_name = ArgS(args, 0);
-  // TODO: Handle optional DD param
 
+  // Parse optional DD (Delete Documents) parameter
+  bool delete_docs = false;
+  if (args.size() > 1) {
+    string_view option = ArgS(args, 1);
+    if (absl::EqualsIgnoreCase(option, "DD")) {
+      delete_docs = true;
+    } else {
+      return cmd_cntx.rb->SendError("Unknown argument");
+    }
+  }
+
+  // Collect document keys (if DD is set), drop index, and delete documents in single transaction
+  vector<vector<string>> shard_doc_keys(delete_docs ? shard_set->size() : 0);
   atomic_uint num_deleted{0};
-  cmd_cntx.tx->ScheduleSingleHop([&](Transaction* t, EngineShard* es) {
+
+  auto cb = [&](Transaction* t, EngineShard* es) {
+    // Step 1: If DD is set, collect all document keys before dropping the index
+    if (delete_docs) {
+      auto* index = es->search_indices()->GetIndex(idx_name);
+      if (index) {
+        shard_doc_keys[es->shard_id()] = index->GetAllKeys();
+      }
+    }
+
+    // Step 2: Drop the index
     if (es->search_indices()->DropIndex(idx_name))
       num_deleted.fetch_add(1);
+
+    // Step 3: If DD is set, delete all documents that were in the index
+    if (delete_docs) {
+      const auto& keys = shard_doc_keys[es->shard_id()];
+      if (!keys.empty()) {
+        auto op_args = t->GetOpArgs(es);
+        auto& db_slice = op_args.GetDbSlice();
+
+        for (const auto& key : keys) {
+          auto it = db_slice.FindMutable(op_args.db_cntx, key).it;
+          if (IsValid(it)) {
+            db_slice.Del(op_args.db_cntx, it);
+          }
+        }
+      }
+    }
+
     return OpStatus::OK;
-  });
+  };
+
+  cmd_cntx.tx->Execute(cb, true);
 
   DCHECK(num_deleted == 0u || num_deleted == shard_set->size());
   if (num_deleted == 0u)
     return cmd_cntx.rb->SendError("-Unknown Index name");
+
   return cmd_cntx.rb->SendOk();
 }
 

src/server/search/search_family_test.cc

@@ -3328,4 +3328,80 @@ TEST_F(SearchFamilyTest, InvalidConfigOptions) {
   EXPECT_THAT(resp, IsArray());
 }
 
+TEST_F(SearchFamilyTest, DropIndexWithDD) {
+  // Create an index on HASH documents
+  Run({"FT.CREATE", "idx", "ON", "HASH", "PREFIX", "1", "doc:", "SCHEMA", "name", "TEXT"});
+
+  // Add some documents
+  Run({"HSET", "doc:1", "name", "Alice"});
+  Run({"HSET", "doc:2", "name", "Bob"});
+  Run({"HSET", "doc:3", "name", "Charlie"});
+
+  // Verify documents exist
+  auto resp = Run({"EXISTS", "doc:1", "doc:2", "doc:3"});
+  EXPECT_THAT(resp, IntArg(3));
+
+  // Verify index works
+  resp = Run({"FT.SEARCH", "idx", "*"});
+  EXPECT_THAT(resp, AreDocIds("doc:1", "doc:2", "doc:3"));
+
+  // Drop index WITHOUT DD - documents should remain
+  Run({"FT.DROPINDEX", "idx"});
+  resp = Run({"EXISTS", "doc:1", "doc:2", "doc:3"});
+  EXPECT_THAT(resp, IntArg(3));
+
+  // Create index again
+  Run({"FT.CREATE", "idx", "ON", "HASH", "PREFIX", "1", "doc:", "SCHEMA", "name", "TEXT"});
+
+  // Verify index works again
+  resp = Run({"FT.SEARCH", "idx", "*"});
+  EXPECT_THAT(resp, AreDocIds("doc:1", "doc:2", "doc:3"));
+
+  // Drop index WITH DD - documents should be deleted
+  Run({"FT.DROPINDEX", "idx", "DD"});
+  resp = Run({"EXISTS", "doc:1", "doc:2", "doc:3"});
+  EXPECT_THAT(resp, IntArg(0));
+}
+
+TEST_F(SearchFamilyTest, DropIndexWithDDJson) {
+  // Create an index on JSON documents
+  Run({"FT.CREATE", "jidx", "ON", "JSON", "PREFIX", "1", "jdoc:", "SCHEMA", "$.name", "AS", "name",
+       "TEXT"});
+
+  // Add some JSON documents
+  Run({"JSON.SET", "jdoc:1", "$", R"({"name": "Alice"})"});
+  Run({"JSON.SET", "jdoc:2", "$", R"({"name": "Bob"})"});
+  Run({"JSON.SET", "jdoc:3", "$", R"({"name": "Charlie"})"});
+
+  // Verify documents exist
+  auto resp = Run({"EXISTS", "jdoc:1", "jdoc:2", "jdoc:3"});
+  EXPECT_THAT(resp, IntArg(3));
+
+  // Verify index works
+  resp = Run({"FT.SEARCH", "jidx", "*"});
+  EXPECT_THAT(resp, AreDocIds("jdoc:1", "jdoc:2", "jdoc:3"));
+
+  // Drop index WITH DD - documents should be deleted
+  Run({"FT.DROPINDEX", "jidx", "DD"});
+  resp = Run({"EXISTS", "jdoc:1", "jdoc:2", "jdoc:3"});
+  EXPECT_THAT(resp, IntArg(0));
+}
+
+TEST_F(SearchFamilyTest, DropIndexWithInvalidOption) {
+  // Create an index
+  Run({"FT.CREATE", "idx", "ON", "HASH", "PREFIX", "1", "doc:", "SCHEMA", "name", "TEXT"});
+
+  // Try to drop with invalid option
+  auto resp = Run({"FT.DROPINDEX", "idx", "INVALID"});
+  EXPECT_THAT(resp, ErrArg("Unknown argument"));
+
+  // Index should still exist - verify it can be searched
+  Run({"HSET", "doc:1", "name", "test"});
+  resp = Run({"FT.SEARCH", "idx", "*"});
+  EXPECT_THAT(resp, AreDocIds("doc:1"));
+
+  // Clean up
+  Run({"FT.DROPINDEX", "idx", "DD"});
+}
+
 }  // namespace dfly