size_t maxBatchSize; // Maximum batch size used during batches mode

size_t maxBatchIteration; // Iteration (zero-based) where the maximum batch size occurred

if (it->type == VECTOR_DISTANCE) {

printProfileVectorSearchMode(VECSIM_RANGE_QUERY);

}

printProfileVectorSearchMode(hi->searchMode);

printProfileMaxBatchSize(hi);

printProfileMaxBatchIteration(hi);

#define printProfileMaxBatchSize(hybrid_reader) \

RedisModule_ReplyKV_LongLong(reply, "Largest batch size", (hybrid_reader)->maxBatchSize)

#define printProfileMaxBatchIteration(hybrid_reader) \

RedisModule_ReplyKV_LongLong(reply, "Largest batch iteration (zero based)", (hybrid_reader)->maxBatchIteration)

#define printProfileVectorSearchMode(searchMode) \

RedisModule_ReplyKV_SimpleString(reply, "Vector search mode", VecSimSearchMode_ToString(searchMode))

const char *VecSimSearchMode_ToString(VecSearchMode vecsimSearchMode) {

switch (vecsimSearchMode) {

case EMPTY_MODE:

return "EMPTY_MODE";

case STANDARD_KNN:

return "STANDARD_KNN";

case HYBRID_ADHOC_BF:

return "HYBRID_ADHOC_BF";

case HYBRID_BATCHES:

return "HYBRID_BATCHES";

case HYBRID_BATCHES_TO_ADHOC_BF:

return "HYBRID_BATCHES_TO_ADHOC_BF";

case RANGE_QUERY:

return "RANGE_QUERY";

}

return NULL;

}

const char *VecSimSearchMode_ToString(VecSearchMode vecsimSearchMode);

expected_iterators_res = ['Type', 'VECTOR', 'Number of reading operations', 3, 'Vector search mode', 'STANDARD_KNN']

expected_iterators_res = ['Type', 'METRIC - VECTOR DISTANCE', 'Number of reading operations', 2, 'Vector search mode', 'RANGE_QUERY']

expected_iterators_res = ['Type', 'VECTOR', 'Number of reading operations', 2, 'Vector search mode', 'HYBRID_ADHOC_BF', 'Child iterator',

expected_iterators_res = ['Type', 'VECTOR', 'Number of reading operations', 3, 'Vector search mode', 'HYBRID_BATCHES', 'Batches number', 2, 'Largest batch size', 4, 'Largest batch iteration (zero based)', 0, 'Child iterator',

expected_iterators_res = ['Type', 'VECTOR', 'Number of reading operations', 0, 'Vector search mode', 'HYBRID_BATCHES_TO_ADHOC_BF', 'Batches number', 2, 'Largest batch size', 13, 'Largest batch iteration (zero based)', 1, 'Child iterator',

expected_iterators_res = ['Type', 'VECTOR', 'Number of reading operations', 0, 'Vector search mode', 'HYBRID_BATCHES', 'Batches number', 13, 'Largest batch size', 20001, 'Largest batch iteration (zero based)', 12, 'Child iterator',

expected_iterators_res = ['Type', 'VECTOR', 'Number of reading operations', 0, 'Vector search mode', 'HYBRID_BATCHES', 'Batches number', 200, 'Largest batch size', 100, 'Largest batch iteration (zero based)', 0, 'Child iterator',

expected_iterators_res = ['Type', 'VECTOR', 'Number of reading operations', 0, 'Vector search mode', 'HYBRID_BATCHES_TO_ADHOC_BF', 'Batches number', 2, 'Largest batch size', 100, 'Largest batch iteration (zero based)', 0, 'Child iterator',

def testProfileVectorSearchMode():

"""Test Vector search mode field in FT.PROFILE for both SEARCH and AGGREGATE"""

env = Env(moduleArgs='DEFAULT_DIALECT 2', protocol=3) # Use RESP3 for easier dict access

conn = getConnectionByEnv(env)

env.expect('FT.CREATE', 'idx', 'SCHEMA', 'v', 'VECTOR', 'FLAT', '6', 'TYPE', 'FLOAT32', 'DIM', '2', 'DISTANCE_METRIC', 'L2', 't', 'TEXT').ok()

conn.execute_command('hset', '1', 'v', 'bababaca', 't', "hello")

conn.execute_command('hset', '2', 'v', 'babababa', 't', "hello")

conn.execute_command('hset', '3', 'v', 'aabbaabb', 't', "hello")

conn.execute_command('hset', '4', 'v', 'bbaabbaa', 't', "hello world")

conn.execute_command('hset', '5', 'v', 'aaaabbbb', 't', "hello world")

# Helper function to test both SEARCH and AGGREGATE

def verify_search_mode(query_type, query, params, expected_mode, expected_iterator_type='VECTOR'):

scenario_message = f"query_type: {query_type}, query: {query}, params: {params}, expected_mode: {expected_mode}"

"""

cmd = ['FT.PROFILE', 'idx', query_type, 'QUERY', query]

cmd.extend(['PARAMS'] + [str(len(params))] + params)

res = env.cmd(*cmd)

# Navigate to iterator profile (RESP3 dict structure)

shards = res['Profile']['Shards']

env.assertGreater(len(shards), 0, message=scenario_message)

# Check at least one shard has the expected search mode

# res['Profile']['Shards'][0]['Iterators profile']['Vector search mode']

found = False

for shard in shards:

iter_profile = shard['Iterators profile']

if iter_profile['Type'] == expected_iterator_type:

env.assertEqual(iter_profile['Vector search mode'], expected_mode, message=scenario_message)

found = True

break

env.assertTrue(found, message=f"{scenario_message}: Expected iterator type {expected_iterator_type} not found")

# Test 1: STANDARD_KNN

verify_search_mode('SEARCH', '*=>[KNN 3 @v $vec]', ['vec', 'aaaaaaaa'], 'STANDARD_KNN')

verify_search_mode('AGGREGATE', '*=>[KNN 3 @v $vec]', ['vec', 'aaaaaaaa'], 'STANDARD_KNN')

# Test 2: HYBRID_ADHOC_BF

verify_search_mode('SEARCH', '(@t:hello world)=>[KNN 3 @v $vec]', ['vec', 'aaaaaaaa'], 'HYBRID_ADHOC_BF')

verify_search_mode('AGGREGATE', '(@t:hello world)=>[KNN 3 @v $vec]', ['vec', 'aaaaaaaa'], 'HYBRID_ADHOC_BF')

# Test 3: RANGE_QUERY (uses METRIC_ITERATOR)

verify_search_mode('SEARCH', '@v:[VECTOR_RANGE 3e36 $vec]=>{$yield_distance_as:dist}',

['vec', 'aaaaaaaa'], 'RANGE_QUERY', 'METRIC - VECTOR DISTANCE')

verify_search_mode('AGGREGATE', '@v:[VECTOR_RANGE 3e36 $vec]=>{$yield_distance_as:dist}',

['vec', 'aaaaaaaa'], 'RANGE_QUERY', 'METRIC - VECTOR DISTANCE')

# Test 4: HYBRID_BATCHES

verify_search_mode('SEARCH', '(@t:hello world)=>[KNN 3 @v $vec HYBRID_POLICY BATCHES BATCH_SIZE 100]', ['vec', 'aaaaaaaa'], 'HYBRID_BATCHES')

verify_search_mode('AGGREGATE', '(@t:hello world)=>[KNN 3 @v $vec HYBRID_POLICY BATCHES BATCH_SIZE 100]', ['vec', 'aaaaaaaa'], 'HYBRID_BATCHES')

# Running HYBRID_BATCHES_TO_ADHOC_BF on cluster requires much more data and doesn't add a significant value

if env.isCluster():

return

for i in range(6, 5000):

conn.execute_command('hset', str(i), 'v', 'bababada', 't', "hello")

# Add another 10K docs with "other" tag for HYBRID_BATCHES_TO_ADHOC_BF test

for i in range(5000, 10001):

conn.execute_command('hset', str(i), 'v', '????????', 't', "other")

# Test 5: HYBRID_BATCHES_TO_ADHOC_BF

# Query: "hello" (10K docs) AND "other" (10K docs) → intersection is 0 (disjoint sets)

# High estimated results → starts BATCHES, but 0 actual results → switches to ADHOC_BF

verify_search_mode('SEARCH', '(@t:hello other)=>[KNN 3 @v $vec BATCH_SIZE 100]', ['vec', '????????'], 'HYBRID_BATCHES_TO_ADHOC_BF')

verify_search_mode('AGGREGATE', '(@t:hello other)=>[KNN 3 @v $vec BATCH_SIZE 100]', ['vec', '????????'], 'HYBRID_BATCHES_TO_ADHOC_BF')