[calcite] branch master updated: [CALCITE-3829] MergeJoinEnumerator should not use inputs enumerators until it is really required

[rubenql]

This is an automated email from the ASF dual-hosted git repository.

rubenql pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/calcite.git


The following commit(s) were added to refs/heads/master by this push:
     new ffcfb92  [CALCITE-3829] MergeJoinEnumerator should not use inputs 
enumerators until it is really required
ffcfb92 is described below

commit ffcfb92247acbc7c50ee7812aad0060b94bafcd9
Author: rubenada <rube...@gmail.com>
AuthorDate: Fri Mar 20 11:34:01 2020 +0100

    [CALCITE-3829] MergeJoinEnumerator should not use inputs enumerators until 
it is really required
---
 .../apache/calcite/linq4j/EnumerableDefaults.java  | 43 ++++++++++++++++------
 1 file changed, 32 insertions(+), 11 deletions(-)

diff --git 
a/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java 
b/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java
index 9a7cd66..80ac509 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java
@@ -2011,8 +2011,7 @@ public abstract class EnumerableDefaults {
     }
     return new AbstractEnumerable<TResult>() {
       public Enumerator<TResult> enumerator() {
-        return new MergeJoinEnumerator<>(outer.enumerator(),
-            inner.enumerator(), outerKeySelector, innerKeySelector,
+        return new MergeJoinEnumerator<>(outer, inner, outerKeySelector, 
innerKeySelector,
             extraPredicate, resultSelector);
       }
     };
@@ -3828,8 +3827,10 @@ public abstract class EnumerableDefaults {
       implements Enumerator<TResult> {
     private final List<TSource> lefts = new ArrayList<>();
     private final List<TInner> rights = new ArrayList<>();
-    private final Enumerator<TSource> leftEnumerator;
-    private final Enumerator<TInner> rightEnumerator;
+    private final Enumerable<TSource> leftEnumerable;
+    private final Enumerable<TInner> rightEnumerable;
+    private Enumerator<TSource> leftEnumerator = null;
+    private Enumerator<TInner> rightEnumerator = null;
     private final Function1<TSource, TKey> outerKeySelector;
     private final Function1<TInner, TKey> innerKeySelector;
     // extra predicate in case of non equi-join, in case of equi-join it will 
be null
@@ -3838,14 +3839,14 @@ public abstract class EnumerableDefaults {
     private boolean done;
     private Enumerator<TResult> results;
 
-    MergeJoinEnumerator(Enumerator<TSource> leftEnumerator,
-        Enumerator<TInner> rightEnumerator,
+    MergeJoinEnumerator(Enumerable<TSource> leftEnumerable,
+        Enumerable<TInner> rightEnumerable,
         Function1<TSource, TKey> outerKeySelector,
         Function1<TInner, TKey> innerKeySelector,
         Predicate2<TSource, TInner> extraPredicate,
         Function2<TSource, TInner, TResult> resultSelector) {
-      this.leftEnumerator = leftEnumerator;
-      this.rightEnumerator = rightEnumerator;
+      this.leftEnumerable = leftEnumerable;
+      this.rightEnumerable = rightEnumerable;
       this.outerKeySelector = outerKeySelector;
       this.innerKeySelector = innerKeySelector;
       this.extraPredicate = extraPredicate;
@@ -3853,9 +3854,23 @@ public abstract class EnumerableDefaults {
       start();
     }
 
+    private Enumerator<TSource> startLeftEnumerator() {
+      if (leftEnumerator == null) {
+        leftEnumerator = leftEnumerable.enumerator();
+      }
+      return leftEnumerator;
+    }
+
+    private Enumerator<TInner> startRightEnumerator() {
+      if (rightEnumerator == null) {
+        rightEnumerator = rightEnumerable.enumerator();
+      }
+      return rightEnumerator;
+    }
+
     private void start() {
-      if (!leftEnumerator.moveNext()
-          || !rightEnumerator.moveNext()
+      if (!startLeftEnumerator().moveNext()
+          || !startRightEnumerator().moveNext()
           || !advance()) {
         done = true;
         results = Linq4j.emptyEnumerator();
@@ -3978,11 +3993,17 @@ public abstract class EnumerableDefaults {
     public void reset() {
       done = false;
       leftEnumerator.reset();
-      rightEnumerator.reset();
+      if (rightEnumerator != null) {
+        rightEnumerator.reset();
+      }
       start();
     }
 
     public void close() {
+      leftEnumerator.close();
+      if (rightEnumerator != null) {
+        rightEnumerator.close();
+      }
     }
   }