arangodb · KVS85 · Jun 19, 2021 · Jun 16, 2021 · Jun 19, 2021 · Jun 19, 2021
diff --git a/3rdParty/iresearch/core/search/disjunction.hpp b/3rdParty/iresearch/core/search/disjunction.hpp
@@ -735,6 +735,9 @@ class disjunction final
   virtual void visit(void* ctx, bool (*visitor)(void*, Adapter&)) override {
     assert(ctx);
     assert(visitor);
+    if (heap_.empty()) {
+      return;
+    }
     hitch_all_iterators();
     auto& lead = itrs_[heap_.back()];
     auto cont = visitor(ctx, lead);
@@ -876,6 +879,7 @@ class disjunction final
   }
 
   std::pair<heap_iterator, heap_iterator> hitch_all_iterators() {
+    assert(!heap_.empty());
     // hitch all iterators in head to the lead (current doc_)
     auto begin = heap_.begin(), end = heap_.end()-1;
 

diff --git a/CHANGELOG b/CHANGELOG
@@ -1,6 +1,9 @@
 v3.7.13 (XXXX-XX-XX)
 --------------------
 
+* Fix DEVSUP-753: now it is safe to call visit on exhausted disjunction
+  iterator.
+
 * Fix URL request parsing in case data is handed in in small chunks.
   Previously the URL could be cut off if the chunk size was smaller than the URL
   size.

diff --git a/tests/js/common/aql/aql-view-arangosearch-noncluster.js b/tests/js/common/aql/aql-view-arangosearch-noncluster.js
@@ -2205,7 +2205,55 @@ function iResearchAqlTestSuite () {
       let res= db._query("FOR doc IN WithPrimarySort SEARCH ANALYZER(doc.field3 == 1, 'customAnalyzer') "
       + " OPTIONS { waitForSync : true } SORT doc._key  LIMIT 0, 50  RETURN doc ").toArray();
       assertEqual(1, res.length);
+    },
+
+    testDisjunctionVisit : function() {
+      let queryColl = "DisjunctionCollection";
+      let queryView = "DisjunctionView";
+      try {
+        db._drop(queryColl);
+        db._dropView(queryView);
+        let coll = db._create(queryColl);
+        let view = db._createView(queryView, "arangosearch", { 
+              links: { 
+                  [queryColl] : { 
+                      fields: {
+                        value: { analyzers:['identity', 'text_en'] }
+                      }
+                  }
+              }
+        });
+        let documents = [
+          {"value":"test"},
+          // these docs will make STARTS_WITH more "costly" than PHRASE and conjunction will use PHRASE as lead! 
+          {"value":"test1234"},
+          {"value":"test21321312312"},
+          {"value":"test213213123122"},
+          {"value":"test2132131231222"},
+          {"value":"test21321312312222"},
+          {"value":"test2132131231222322"},
+          {"value":"test2132131231231231222322"},
+          // this will make PHRASE iterator not use small_disjunction (more than 5 candidates for LEVENSHTEIN)
+          {"value":"rest"},
+          {"value":"arest"},
+          {"value":"brest"},
+          {"value":"zest"},
+          {"value":"qest"}];
+        db[queryColl].save(documents);
+        let res = db._query("FOR d IN " + queryView +" SEARCH "
+                  + " (ANALYZER(PHRASE(d.value, {LEVENSHTEIN_MATCH : ['test', 2, true]}), 'text_en') "
+                  + " && ANALYZER(STARTS_WITH(d.value, 'test'),'text_en')) OR "
+                  + " BOOST(PHRASE(d.value, 'test144', 'identity'), 10) "
+                  + " OPTIONS {waitForSync:true} SORT BM25(d) DESC LIMIT 20 "
+                  + " RETURN {'Score':BM25(d), 'Id' : d.value, 'Entity' : d }").toArray();
+        assertEqual(1, res.length);
+
+      } finally {
+        db._drop(queryColl);
+        db._dropView(queryView);
+      }
     }
+
   };
 }