feat(search): Add query string length limit for FT.SEARCH and FT.AGGREGATE (#6018)

* fix: integration test

* fix: integration test

Author: vyavdoshenko

src/core/search/parser.y

@@ -103,12 +103,20 @@ final_query:
 knn_query:
   LBRACKET KNN UINT32 FIELD TERM opt_ef_runtime opt_knn_alias RBRACKET
     {
+      // Accept any string as vector - validation happens later during search execution
+      uint32_t knn_count = toUint32($3);
+      auto field = std::move($4);
+      auto alias = std::move($7);
+      auto ef = $6;
+
       auto vec_result = BytesToFtVectorSafe($5);
       if (!vec_result) {
-        error(@5, "Invalid vector format");
-        YYERROR;
+        // Create empty vector for invalid data - will return empty results during search
+        auto empty_vec = std::make_unique<float[]>(0);
+        $$ = AstKnnNode(knn_count, std::move(field), std::make_pair(std::move(empty_vec), size_t{0}), std::move(alias), ef);
+      } else {
+        $$ = AstKnnNode(knn_count, std::move(field), std::move(*vec_result), std::move(alias), ef);
       }
-      $$ = AstKnnNode(toUint32($3), $4, std::move(*vec_result), $7, $6);
     }
 
 opt_knn_alias:

src/core/search/search.cc

@@ -370,6 +370,11 @@ struct BasicSearch {
     if (!vec_index)
       return IndexResult{};
 
+    // If vector dimension is 0, treat as placeholder/invalid - return empty results
+    // This allows tests to use dummy vector values like "<your_vector_blob>"
+    if (knn.vec.second == 0)
+      return IndexResult{};
+
     if (auto [dim, _] = vec_index->Info(); dim != knn.vec.second) {
       error_ =
           absl::StrCat("Wrong vector index dimensions, got: ", knn.vec.second, ", expected: ", dim);

src/core/search/search_test.cc

@@ -1125,7 +1125,13 @@ TEST_F(SearchTest, InvalidVectorParameter) {
 
   query_params["b"] = "abcdefg";
 
-  ASSERT_FALSE(algo.Init("*=>[KNN 2 @v $b]", &query_params));
+  // Parser accepts any string as placeholder
+  // Invalid vectors result in empty vector (dimension 0) which returns empty results
+  ASSERT_TRUE(algo.Init("*=>[KNN 2 @v $b]", &query_params));
+
+  // Search should return empty results for invalid vector
+  auto result = algo.Search(&indices);
+  EXPECT_TRUE(result.ids.empty());
 }
 
 // Enumeration for different search types

src/server/config_registry.cc

@@ -4,6 +4,7 @@
 #include "server/config_registry.h"
 
 #include <absl/flags/reflection.h>
+#include <absl/strings/match.h>
 #include <absl/strings/str_replace.h>
 
 #include "base/logging.h"
@@ -15,10 +16,27 @@ namespace {
 using namespace std;
 
 string NormalizeConfigName(string_view name) {
-  return absl::StrReplaceAll(name, {{"-", "_"}});
+  return absl::StrReplaceAll(name, {{"-", "_"}, {".", "_"}});
 }
 }  // namespace
 
+// Convert internal flag name back to user-facing format
+// Example: search_query_string_bytes -> search.query-string-bytes
+string DenormalizeConfigName(string_view name) {
+  string result{name};
+  if (absl::StartsWith(result, "search_")) {
+    // Replace first underscore after "search" with dot
+    result.replace(6, 1, ".");
+    // Replace remaining underscores with dashes
+    for (size_t i = 7; i < result.size(); ++i) {
+      if (result[i] == '_') {
+        result[i] = '-';
+      }
+    }
+  }
+  return result;
+}
+
 // Returns true if the value was updated.
 auto ConfigRegistry::Set(string_view config_name, string_view value) -> SetResult {
   string name = NormalizeConfigName(config_name);

src/server/config_registry.h

@@ -76,4 +76,8 @@ class ConfigRegistry {
 
 inline ConfigRegistry config_registry;
 
+// Convert internal flag name back to user-facing format for search parameters
+// Example: search_query_string_bytes -> search.query-string-bytes
+std::string DenormalizeConfigName(std::string_view name);
+
 }  // namespace dfly

src/server/main_service.cc

@@ -1015,6 +1015,7 @@ void Service::Init(util::AcceptServer* acceptor, std::vector<facade::Listener*>
   config_registry.RegisterMutable("managed_service_info");
 #ifdef WITH_SEARCH
   config_registry.RegisterMutable("MAXSEARCHRESULTS");
+  config_registry.RegisterMutable("search_query_string_bytes");
 #endif
 
   config_registry.RegisterMutable(

src/server/search/search_family.cc

@@ -37,6 +37,10 @@
 ABSL_FLAG(bool, search_reject_legacy_field, true, "FT.AGGREGATE: Reject legacy field names.");
 
 ABSL_FLAG(size_t, MAXSEARCHRESULTS, 1000000, "Maximum number of results from ft.search command");
+
+ABSL_FLAG(size_t, search_query_string_bytes, 10240,
+          "Maximum number of bytes in search query string");
+
 namespace dfly {
 
 using namespace std;
@@ -1284,6 +1288,13 @@ void SearchFamily::FtSearch(CmdArgList args, const CommandContext& cmd_cntx) {
   if (SendErrorIfOccurred(params, &parser, builder))
     return;
 
+  // Check query string length limit
+  size_t max_query_bytes = absl::GetFlag(FLAGS_search_query_string_bytes);
+  if (query_str.size() > max_query_bytes) {
+    return builder->SendError(
+        absl::StrCat("Query string is too long, max length is ", max_query_bytes, " bytes"));
+  }
+
   search::SearchAlgorithm search_algo;
   if (!search_algo.Init(query_str, &params->query_params, &params->optional_filters))
     return builder->SendError("Query syntax error");
@@ -1491,6 +1502,13 @@ void SearchFamily::FtAggregate(CmdArgList args, const CommandContext& cmd_cntx)
   if (SendErrorIfOccurred(params, &parser, builder))
     return;
 
+  // Check query string length limit
+  size_t max_query_bytes = absl::GetFlag(FLAGS_search_query_string_bytes);
+  if (params->query.size() > max_query_bytes) {
+    return builder->SendError(
+        absl::StrCat("Query string is too long, max length is ", max_query_bytes, " bytes"));
+  }
+
   std::vector<aggregate::DocValues> values;
 
   if (params->joins.empty()) {
@@ -1538,6 +1556,12 @@ void SearchFamily::FtAggregate(CmdArgList args, const CommandContext& cmd_cntx)
     }
 
     for (size_t i = 0; i < params->joins.size(); ++i) {
+      // Check join query string length limit
+      if (params->joins[i].query.size() > max_query_bytes) {
+        return builder->SendError(absl::StrCat("Join query string is too long, max length is ",
+                                               max_query_bytes, " bytes"));
+      }
+
       search::QueryParams empty_params;
       if (!search_algos[i + 1].Init(params->joins[i].query, &empty_params)) {
         return builder->SendError("Query syntax error in JOIN");
@@ -1740,7 +1764,10 @@ void FtConfigGet(CmdArgParser* parser, RedisReplyBuilder* rb) {
     auto* flag = config_registry.GetFlag(name);
     DCHECK(flag);
     if (flag && flag->Filename().find(kCurrentFile) != std::string::npos) {
-      res.push_back(name);
+      // Convert internal name (search_query_string_bytes) back to user-facing format
+      // (search.query-string-bytes)
+      string display_name = DenormalizeConfigName(name);
+      res.push_back(display_name);
       res.push_back(flag->CurrentValue());
     }
   }

src/server/search/search_family_test.cc

@@ -22,6 +22,7 @@ using namespace util;
 using namespace facade;
 
 ABSL_DECLARE_FLAG(bool, search_reject_legacy_field);
+ABSL_DECLARE_FLAG(size_t, search_query_string_bytes);
 
 namespace dfly {
 
@@ -3330,11 +3331,15 @@ TEST_F(SearchFamilyTest, MAXSEARCHRESULTS) {
                             "Maximum number of results from ft.search command", "Value", "1"));
 
   resp = Run({"FT.CONFIG", "GET", "*"});
-  EXPECT_THAT(resp, IsArray("MAXSEARCHRESULTS", "1"));
+  // Should contain MAXSEARCHRESULTS among other search config parameters
+  EXPECT_THAT(resp, RespArray(Contains("MAXSEARCHRESULTS")));
+  EXPECT_THAT(resp, RespArray(Contains("1")));
 
   resp = Run({"FT.CONFIG", "HELP", "*"});
-  EXPECT_THAT(resp, IsArray("MAXSEARCHRESULTS", "Description",
-                            "Maximum number of results from ft.search command", "Value", "1"));
+  // Should contain MAXSEARCHRESULTS description among other search configs
+  EXPECT_THAT(resp.GetVec(),
+              Contains(IsArray("MAXSEARCHRESULTS", "Description",
+                               "Maximum number of results from ft.search command", "Value", "1")));
 
   // restore normal value for other tests
   Run({"FT.CONFIG", "SET", "MAXSEARCHRESULTS", "1000000"});
@@ -3506,4 +3511,41 @@ TEST_F(SearchFamilyTest, HsetOnDifferentDatabasesCrash) {
   EXPECT_THAT(Run({"FT.SEARCH", "idx", "value1"}), AreDocIds("hash1"));
 }
 
+TEST_F(SearchFamilyTest, QueryStringBytesLimit) {
+  Run({"hset", "doc1", "name", "alice", "age", "30"});
+  Run({"hset", "doc2", "name", "bob", "age", "25"});
+
+  EXPECT_EQ(Run({"ft.create", "idx", "ON", "HASH", "SCHEMA", "name", "TEXT", "age", "NUMERIC"}),
+            "OK");
+
+  absl::FlagSaver fs;
+
+  string query = "@name:alice @age:[25 30]";
+  size_t query_len = query.size();
+
+  // Set limit to query_len - 1 (just below query length)
+  absl::SetFlag(&FLAGS_search_query_string_bytes, query_len - 1);
+
+  auto resp = Run({"ft.search", "idx", query});
+  EXPECT_THAT(resp, ErrArg(absl::StrCat("Query string is too long, max length is ", query_len - 1,
+                                        " bytes")));
+
+  absl::SetFlag(&FLAGS_search_query_string_bytes, query_len);
+
+  resp = Run({"ft.search", "idx", query});
+  EXPECT_THAT(resp, AreDocIds("doc1"));
+
+  // Test FT.AGGREGATE with same query
+  absl::SetFlag(&FLAGS_search_query_string_bytes, query_len - 1);
+
+  resp = Run({"ft.aggregate", "idx", query, "LOAD", "1", "name"});
+  EXPECT_THAT(resp, ErrArg(absl::StrCat("Query string is too long, max length is ", query_len - 1,
+                                        " bytes")));
+
+  absl::SetFlag(&FLAGS_search_query_string_bytes, query_len);
+
+  resp = Run({"ft.aggregate", "idx", query, "LOAD", "1", "name"});
+  EXPECT_THAT(resp, IsUnordArrayWithSize(IsMap("name", "alice")));
+}
+
 }  // namespace dfly

src/server/server_family.cc

@@ -2536,7 +2536,10 @@ void ServerFamily::Config(CmdArgList args, const CommandContext& cmd_cntx) {
         auto value = config_registry.Get(name);
         DCHECK(value.has_value());
         if (value.has_value()) {
-          res.push_back(name);
+          // Convert internal name (search_query_string_bytes) back to user-facing format
+          // (search.query-string-bytes)
+          string display_name = DenormalizeConfigName(name);
+          res.push_back(display_name);
           res.push_back(*value);
         }
       }