fix(query): clarify condition resolution semantics for label queries

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/page/IdHolder.java

@@ -35,11 +35,17 @@
 public abstract class IdHolder {
 
     protected final Query query;
+    private final boolean keepOrder;
     protected boolean exhausted;
 
     public IdHolder(Query query) {
+        this(query, false);
+    }
+
+    public IdHolder(Query query, boolean keepOrder) {
         E.checkNotNull(query, "query");
         this.query = query;
+        this.keepOrder = keepOrder;
         this.exhausted = false;
     }
 
@@ -48,6 +54,10 @@ public Query query() {
     }
 
     public boolean keepOrder() {
+        return this.keepOrder;
+    }
+
+    public boolean continueEmptyPage() {
         return false;
     }
 
@@ -94,13 +104,39 @@ public PageIds fetchNext(String page, long pageSize) {
     public static class PagingIdHolder extends IdHolder {
 
         private final Function<ConditionQuery, PageIds> fetcher;
+        private final boolean continueEmptyPage;
+        private final boolean continuePartialPage;
 
         public PagingIdHolder(ConditionQuery query,
                               Function<ConditionQuery, PageIds> fetcher) {
-            super(query.copy());
+            this(query, fetcher, false);
+        }
+
+        public PagingIdHolder(ConditionQuery query,
+                              Function<ConditionQuery, PageIds> fetcher,
+                              boolean keepOrder) {
+            this(query, fetcher, keepOrder, false, false);
+        }
+
+        public PagingIdHolder(ConditionQuery query,
+                              Function<ConditionQuery, PageIds> fetcher,
+                              boolean keepOrder,
+                              boolean continueEmptyPage) {
+            this(query, fetcher, keepOrder, continueEmptyPage,
+                 continueEmptyPage);
+        }
+
+        public PagingIdHolder(ConditionQuery query,
+                              Function<ConditionQuery, PageIds> fetcher,
+                              boolean keepOrder,
+                              boolean continueEmptyPage,
+                              boolean continuePartialPage) {
+            super(query.copy(), keepOrder);
             E.checkArgument(query.paging(),
                             "Query '%s' must include page info", query);
             this.fetcher = fetcher;
+            this.continueEmptyPage = continueEmptyPage;
+            this.continuePartialPage = continuePartialPage;
         }
 
         @Override
@@ -119,12 +155,23 @@ public PageIds fetchNext(String page, long pageSize) {
 
             PageIds result = this.fetcher.apply((ConditionQuery) this.query);
             assert result != null;
-            if (result.ids().size() < pageSize || result.page() == null) {
+            if (result.empty() && !this.continueEmptyPage) {
+                this.exhausted = true;
+                return PageIds.EMPTY;
+            }
+            if (result.page() == null ||
+                (!this.continuePartialPage &&
+                 result.ids().size() < pageSize)) {
                 this.exhausted = true;
             }
             return result;
         }
 
+        @Override
+        public boolean continueEmptyPage() {
+            return this.continueEmptyPage;
+        }
+
         @Override
         public Set<Id> all() {
             throw new NotImplementedException("PagingIdHolder.all");
@@ -142,7 +189,14 @@ public static class BatchIdHolder extends IdHolder
         public BatchIdHolder(ConditionQuery query,
                              Iterator<BackendEntry> entries,
                              Function<Long, Set<Id>> fetcher) {
-            super(query);
+            this(query, entries, fetcher, false);
+        }
+
+        public BatchIdHolder(ConditionQuery query,
+                             Iterator<BackendEntry> entries,
+                             Function<Long, Set<Id>> fetcher,
+                             boolean keepOrder) {
+            super(query, keepOrder);
             this.entries = entries;
             this.fetcher = fetcher;
             this.count = 0L;

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/page/PageEntryIterator.java

@@ -87,7 +87,13 @@ private boolean fetch() {
             this.remaining -= this.pageResults.total();
             return true;
         } else {
-            this.pageInfo.increase();
+            if (this.pageResults.continueOnEmpty() &&
+                this.pageResults.hasNextPage() &&
+                !this.pageResults.page().equals(this.pageInfo.page())) {
+                this.pageInfo.page(this.pageResults.page());
+            } else {
+                this.pageInfo.increase();
+            }
             return this.fetch();
         }
     }

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/page/QueryList.java

@@ -258,7 +258,7 @@ private QueryResults<R> each(IdHolder holder) {
                     return null;
                 }
 
-                return this.queryByIndexIds(ids);
+                return this.queryByIndexIds(ids, holder.keepOrder());
             });
         }
 
@@ -272,10 +272,13 @@ public PageResults<R> iterator(int index, String page, long pageSize) {
             this.updateResultsFilter(bindQuery);
             PageIds pageIds = holder.fetchNext(page, pageSize);
             if (pageIds.empty()) {
-                return PageResults.emptyIterator();
+                return PageResults.emptyIterator(bindQuery,
+                                                 pageIds.pageState(),
+                                                 holder.continueEmptyPage());
             }
 
-            QueryResults<R> results = this.queryByIndexIds(pageIds.ids());
+            QueryResults<R> results = this.queryByIndexIds(pageIds.ids(),
+                                                           holder.keepOrder());
 
             return new PageResults<>(results, pageIds.pageState());
         }
@@ -330,10 +333,17 @@ public static class PageResults<R> {
 
         private final QueryResults<R> results;
         private final PageState pageState;
+        private final boolean continueOnEmpty;
 
         public PageResults(QueryResults<R> results, PageState pageState) {
+            this(results, pageState, false);
+        }
+
+        public PageResults(QueryResults<R> results, PageState pageState,
+                           boolean continueOnEmpty) {
             this.results = results;
             this.pageState = pageState;
+            this.continueOnEmpty = continueOnEmpty;
         }
 
         public Iterator<R> get() {
@@ -345,6 +355,10 @@ public boolean hasNextPage() {
                                  PageState.EMPTY_BYTES);
         }
 
+        public boolean continueOnEmpty() {
+            return this.continueOnEmpty;
+        }
+
         public Query query() {
             List<Query> queries = this.results.queries();
             E.checkState(queries.size() == 1,
@@ -364,5 +378,18 @@ public long total() {
         public static <R> PageResults<R> emptyIterator() {
             return (PageResults<R>) EMPTY;
         }
+
+        public static <R> PageResults<R> emptyIterator(Query query,
+                                                       PageState pageState) {
+            return emptyIterator(query, pageState, false);
+        }
+
+        public static <R> PageResults<R> emptyIterator(Query query,
+                                                       PageState pageState,
+                                                       boolean continueOnEmpty) {
+            return new PageResults<>(
+                    new QueryResults<>(QueryResults.emptyIterator(), query),
+                    pageState, continueOnEmpty);
+        }
     }
 }