RediSearch · GuyAv46 · Feb 4, 2025 · Feb 4, 2025 · Feb 4, 2025 · Feb 6, 2025
diff --git a/src/debug_commands.c b/src/debug_commands.c
@@ -56,7 +56,7 @@ static void ReplyReaderResults(IndexReader *reader, RedisModuleCtx *ctx) {
   RSIndexResult *r;
   size_t resultSize = 0;
   RedisModule_ReplyWithArray(ctx, REDISMODULE_POSTPONED_ARRAY_LEN);
-  while (iter->Read(iter->ctx, &r) != INDEXREAD_EOF) {
+  while (iter->Read(iter, &r) != INDEXREAD_EOF) {
     RedisModule_ReplyWithLongLong(ctx, r->docId);
     ++resultSize;
   }
@@ -324,12 +324,12 @@ InvertedIndexStats InvertedIndex_DebugReply(RedisModuleCtx *ctx, InvertedIndex *
   REPLY_WITH_STR("values", ARRAY_LEN_VAR(invertedIndexDump));
   START_POSTPONED_LEN_ARRAY(invertedIndexValues);
   RSIndexResult *res = NULL;
-  IndexReader *ir = NewMinimalNumericReader(idx, false);
-  while (INDEXREAD_OK == IR_Read(ir, &res)) {
+  IndexIterator *ir = NewReadIterator(NewMinimalNumericReader(idx, false));
+  while (INDEXREAD_OK == ir->Read(ir, &res)) {
     REPLY_WITH_DOUBLE("value", res->num.value, ARRAY_LEN_VAR(invertedIndexValues));
     REPLY_WITH_LONG_LONG("docId", res->docId, ARRAY_LEN_VAR(invertedIndexValues));
   }
-  IR_Free(ir);
+  ir->Free(ir);
   END_POSTPONED_LEN_ARRAY(invertedIndexValues);
   ARRAY_LEN_VAR(invertedIndexDump)++;
 

diff --git a/src/fork_gc.c b/src/fork_gc.c
@@ -791,15 +791,15 @@ static void resetCardinality(NumGcInfo *info, NumericRange *range, size_t blocks
   }
   // Add the entries that were added since the fork to the HLL
   RSIndexResult *cur;
-  IndexReader *ir = NewMinimalNumericReader(range->entries, false);
+  IndexIterator *ir = NewReadIterator(NewMinimalNumericReader(range->entries, false));
   size_t startIdx = range->entries->size - blocksSinceFork; // Here `blocksSinceFork` > 0
   t_docId startId = range->entries->blocks[startIdx].firstId;
   int rc = IR_SkipTo(ir, startId, &cur);
   while (INDEXREAD_OK == rc) {
     hll_add(&range->hll, &cur->num.value, sizeof(cur->num.value));
     rc = IR_Read(ir, &cur);
   }
-  IR_Free(ir);
+  ReadIterator_Free(ir);
 }
 
 static void applyNumIdx(ForkGC *gc, RedisSearchCtx *sctx, NumGcInfo *ninfo) {

diff --git a/src/geo_index.c b/src/geo_index.c
@@ -150,7 +150,7 @@ IndexIterator *NewGeoRangeIterator(const RedisSearchCtx *ctx, const GeoFilter *g
               NewNumericFilter(ranges[ii].min, ranges[ii].max, 1, 1, true);
       filt->field = gf->field;
       filt->geoFilter = gf;
-      struct indexIterator *numIter = NewNumericFilterIterator(ctx, filt, csx, INDEXFLD_T_GEO, config, &filterCtx);
+      IndexIterator *numIter = NewNumericFilterIterator(ctx, filt, csx, INDEXFLD_T_GEO, config, &filterCtx);
       if (numIter != NULL) {
         iters[itersCount++] = numIter;
       }

diff --git a/src/geometry/query_iterator.cpp b/src/geometry/query_iterator.cpp
@@ -20,7 +20,7 @@
 }
 
 int QueryIterator::read_single(RSIndexResult *&hit) noexcept {
-  if (!base_.isValid || !has_next()) {
+  if (!base_.isValid) {
     return INDEXREAD_EOF;
   }
   t_docId docId = iter_[index_++];
@@ -35,6 +35,10 @@
 }
 
 int QueryIterator::read(RSIndexResult *&hit) noexcept {
+  if (index_ >= len()) {
+    base_.isValid = false;
+    return INDEXREAD_EOF;
+  }
   size_t timeoutCounter = 0;
   int rc = INDEXREAD_OK;
   do {
@@ -46,7 +50,7 @@
   return rc;
 }
 int QueryIterator::skip_to(t_docId docId, RSIndexResult *&hit) {
-  if (!base_.isValid || !has_next()) {
+  if (!base_.isValid) {
     return INDEXREAD_EOF;
   }
   if (docId > iter_.back()) {
@@ -57,8 +61,8 @@
   const auto it = std::ranges::lower_bound(std::ranges::next(std::ranges::begin(iter_), index_),
                                            std::ranges::end(iter_), docId);
   index_ = std::ranges::distance(std::ranges::begin(iter_), it + 1);
-  if (!has_next()) {
-    abort();
+  if (index_ >= len()) {
+    base_.isValid = false;
   }
 
   base_.current->docId = *it;
@@ -72,68 +76,51 @@
 t_docId QueryIterator::current() const noexcept {
   return base_.current->docId;
 }
-int QueryIterator::has_next() const noexcept {
-  return index_ < len();
-}
 std::size_t QueryIterator::len() const noexcept {
   return iter_.size();
 }
-void QueryIterator::abort() noexcept {
-  base_.isValid = false;
-}
 void QueryIterator::rewind() noexcept {
   base_.isValid = true;
   base_.current->docId = 0;
+  base_.LastDocId = 0;
   index_ = 0;
 }
 
 namespace {
-int QIter_Read(void *ctx, RSIndexResult **hit) {
-  return static_cast<QueryIterator *>(ctx)->read(*hit);
+int QIter_Read(IndexIterator *base, RSIndexResult **hit) {
+  return reinterpret_cast<QueryIterator *>(base)->read(*hit);
 }
-int QIter_SkipTo(void *ctx, t_docId docId, RSIndexResult **hit) {
-  return static_cast<QueryIterator *>(ctx)->skip_to(docId, *hit);
-}
-t_docId QIter_LastDocId(void *ctx) {
-  return static_cast<QueryIterator const *>(ctx)->current();
-}
-int QIter_HasNext(void *ctx) {
-  return static_cast<QueryIterator const *>(ctx)->has_next();
+int QIter_SkipTo(IndexIterator *base, t_docId docId, RSIndexResult **hit) {
+  return reinterpret_cast<QueryIterator *>(base)->skip_to(docId, *hit);
 }
 void QIter_Free(IndexIterator *self) {
   using alloc_type = Allocator::TrackingAllocator<QueryIterator>;
-  const auto qi = static_cast<QueryIterator *const>(self->ctx);
+  const auto qi = reinterpret_cast<QueryIterator *const>(self);
   auto alloc = alloc_type{qi->iter_.get_allocator()};
   IndexResult_Free(self->current);
   std::allocator_traits<alloc_type>::destroy(alloc, qi);
   std::allocator_traits<alloc_type>::deallocate(alloc, qi, 1);
 }
-std::size_t QIter_Len(void *ctx) {
-  return static_cast<QueryIterator const *>(ctx)->len();
-}
-void QIter_Abort(void *ctx) {
-  static_cast<QueryIterator *>(ctx)->abort();
+std::size_t QIter_Len(IndexIterator *base) {
+  return reinterpret_cast<QueryIterator const *>(base)->len();
 }
-void QIter_Rewind(void *ctx) {
-  static_cast<QueryIterator *>(ctx)->rewind();
+void QIter_Rewind(IndexIterator *base) {
+  reinterpret_cast<QueryIterator *>(base)->rewind();
 }
 
 }  // anonymous namespace
 
 IndexIterator QueryIterator::init_base(QueryIterator *ctx) {
   return IndexIterator{
-      .isValid = 1,
-      .ctx = ctx,
-      .current = NewVirtualResult(0, RS_FIELDMASK_ALL),
       .type = ID_LIST_ITERATOR,
+      .isValid = true,
+      .isAborted = false,
+      .LastDocId = 0,
+      .current = NewVirtualResult(0, RS_FIELDMASK_ALL),
       .NumEstimated = QIter_Len,
       .Read = QIter_Read,
       .SkipTo = QIter_SkipTo,
-      .LastDocId = QIter_LastDocId,
-      .HasNext = QIter_HasNext,
       .Free = QIter_Free,
-      .Len = QIter_Len,
-      .Abort = QIter_Abort,
       .Rewind = QIter_Rewind,
   };
 }

diff --git a/src/geometry/query_iterator.hpp b/src/geometry/query_iterator.hpp
@@ -50,7 +50,6 @@ struct QueryIterator {
   int read(RSIndexResult *&hit) noexcept;
   int skip_to(t_docId docId, RSIndexResult *&hit);
   t_docId current() const noexcept;
-  int has_next() const noexcept;
   std::size_t len() const noexcept;
   void abort() noexcept;
   void rewind() noexcept;

diff --git a/src/highlight_processor.c b/src/highlight_processor.c
@@ -277,8 +277,8 @@ static const RSIndexResult *getIndexResult(ResultProcessor *rp, t_docId docId) {
   if (!it) {
     return NULL;
   }
-  it->Rewind(it->ctx);
-  if (INDEXREAD_OK != it->SkipTo(it->ctx, docId, &ir)) {
+  it->Rewind(it);
+  if (INDEXREAD_OK != it->SkipTo(it, docId, &ir)) {
     return NULL;
   }
   return ir;