You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by ok...@apache.org on 2016/10/03 14:27:00 UTC

[1/9] tinkerpop git commit: CHANGELOG tweak.

Repository: tinkerpop
Updated Branches:
  refs/heads/master 233a6ba46 -> bc00bb3c4


CHANGELOG tweak.


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/bc00bb3c
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/bc00bb3c
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/bc00bb3c

Branch: refs/heads/master
Commit: bc00bb3c4535aec8229b7770f9e8ab60326117ef
Parents: 62197e2
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Mon Oct 3 08:23:38 2016 -0600
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Mon Oct 3 08:24:17 2016 -0600

----------------------------------------------------------------------
 CHANGELOG.asciidoc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/bc00bb3c/CHANGELOG.asciidoc
----------------------------------------------------------------------
diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index 60e895b..4dc4dc3 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -26,7 +26,7 @@ image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
 TinkerPop 3.2.3 (Release Date: NOT OFFICIALLY RELEASED YET)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-* `FilterRankStrategy` now propagates labels "right" non-`Scoping` filters.
+* `FilterRankStrategy` now propagates labels "right" over non-`Scoping` filters.
 * Fixed a bug in `ConnectiveP` where nested equivalent connectives should be inlined.
 * Fixed a bug in `IncidentToAdjacentStrategy` where `TreeStep` traversals were allowed.
 * Fixed a end-step label bug in `MatchPredicateStrategy`.


[4/9] tinkerpop git commit: Added support for or(has(x), has(y)) to be has(x.or(y)) in InlineFilterStrategy. While doing this, I found a bug in ConnectiveP steps where nested equivalents were not being inlined. That bug has been fixed. Added test cases to

Posted by ok...@apache.org.
Added support for or(has(x),has(y)) to be has(x.or(y)) in InlineFilterStrategy. While doing this, I found a bug in ConnectiveP steps where nested equivalents were not being inlined. That bug has been fixed. Added test cases to PTest to demonstrate proper inlining and nesting of ConnectivePs. I left two TODOs. One regarding match()-pulls that are labeled (interfering with FilterRankStrategy) and one regarding, has(x).has(y) being turned into has(x.and(y)). The reason why the latter isn't done now as it may greatly mess up providers who just rely on eq() for index lookups and are not smart enough to look into and()/or() predicates.


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/8eb0fdde
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/8eb0fdde
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/8eb0fdde

Branch: refs/heads/master
Commit: 8eb0fdded4fd8943a1541fda33e0785ea10751ee
Parents: 233a6ba
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Thu Sep 29 10:39:20 2016 -0600
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Mon Oct 3 08:24:17 2016 -0600

----------------------------------------------------------------------
 CHANGELOG.asciidoc                              |   3 +-
 .../upgrade/release-3.2.x-incubating.asciidoc   |  18 ++
 .../optimization/InlineFilterStrategy.java      |  45 +++-
 .../gremlin/process/traversal/util/AndP.java    |   8 +-
 .../process/traversal/util/ConnectiveP.java     |   3 +-
 .../gremlin/process/traversal/util/OrP.java     |   9 +-
 .../gremlin/process/traversal/PTest.java        | 245 ++++++++++---------
 .../optimization/InlineFilterStrategyTest.java  |  18 ++
 .../TinkerGraphStepStrategyTest.java            |   3 +-
 9 files changed, 233 insertions(+), 119 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/8eb0fdde/CHANGELOG.asciidoc
----------------------------------------------------------------------
diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index ade43cd..d204b44 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -26,6 +26,7 @@ image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
 TinkerPop 3.2.3 (Release Date: NOT OFFICIALLY RELEASED YET)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+* Fixed a bug in `ConnectiveP` where nested equivalent connectives should be inlined.
 * Fixed a bug in `IncidentToAdjacentStrategy` where `TreeStep` traversals were allowed.
 * Fixed a end-step label bug in `MatchPredicateStrategy`.
 * Fixed a bug in `MatchPredicateStrategy` where inlined traversals did not have strategies applied to it.
@@ -33,7 +34,7 @@ TinkerPop 3.2.3 (Release Date: NOT OFFICIALLY RELEASED YET)
 * Added `TraversalHelper.copyLabels()` for copying (or moving) labels form one step to another.
 * Added `TraversalHelper.applySingleLevelStrategies()` which will apply a subset of strategies but not walk the child tree.
 * Added the concept that hidden labels using during traversal compilation are removed at the end during `StandardVerificationStrategy`. (*breaking*)
-* Added `InlineFilterStrategy` which will determine if a `TraversalFilterStep`, `AndStep`, `MatchStep` children are filters and if so, inline them.
+* Added `InlineFilterStrategy` which will determine if a `TraversalFilterStep`, `AndStep`, `OrStep`, `MatchStep` children are filters and if so, inline them.
 * Removed `IdentityRemovalStrategy` from the default listing as its not worth the clock cycles.
 * Removed the "!" symbol in `NotStep.toString()` as it is confusing and the `NotStep`-name is sufficient.
 * Fixed a bug in `TraversalVertexProgram` (OLAP) around ordering and connectives (i.e. `and()` and `or()`).

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/8eb0fdde/docs/src/upgrade/release-3.2.x-incubating.asciidoc
----------------------------------------------------------------------
diff --git a/docs/src/upgrade/release-3.2.x-incubating.asciidoc b/docs/src/upgrade/release-3.2.x-incubating.asciidoc
index 0ba09bd..49790af 100644
--- a/docs/src/upgrade/release-3.2.x-incubating.asciidoc
+++ b/docs/src/upgrade/release-3.2.x-incubating.asciidoc
@@ -171,6 +171,15 @@ uses of these exception builders as they will be removed in the future.
 
 See: link:https://issues.apache.org/jira/browse/TINKERPOP-944[TINKERPOP-944]
 
+Hidden Step Labels for Compilation Only
++++++++++++++++++++++++++++++++++++++++
+
+In order for `SubgraphStrategy` to work, it was necessary to have multi-level children communicate with one another
+via hidden step labels. It was decided that hidden step labels are for compilation purposes only and will be removed
+prior to traversal evaluation. This is a valid decision given that hidden labels for graph system providers are
+not allowed to be used by users. Likewise, hidden labels for steps should not be allowed be used by
+users as well.
+
 PropertyMapStep with Selection Traversal
 ++++++++++++++++++++++++++++++++++++++++
 
@@ -181,6 +190,15 @@ and if so, use that in their introspection for respective strategies. This model
 See: link:https://issues.apache.org/jira/browse/TINKERPOP-1456[TINKERPOP-1456],
 link:https://issues.apache.org/jira/browse/TINKERPOP-844[TINKERPOP-844]
 
+ConnectiveP Nesting Inlined
++++++++++++++++++++++++++++
+
+There was a bug in `ConnectiveP` (`AndP`/`OrP`), where `eq(1).and(eq(2).and(eq(3)))` was `OrP(eq(1),AndP(eq(2),eq(3)))`
+instead of unnested/inlined as `OrP(eq(1),eq(2),eq(3))`. Likewise, for `AndP`. If a provider was leveraging `ConnectiveP`
+predicates for their custom steps (e.g. graph- or vertex-centric index lookups), then they should be aware of the inlining
+and can simplify any and/or-tree walking code in their respective `ProviderOptimizationStrategy`.
+
+See: link:https://issues.apache.org/jira/browse/TINKERPOP-1470[TINKERPOP-1470]
 
 TinkerPop 3.2.2
 ---------------

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/8eb0fdde/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
index 7452b3b..0b7a5cc 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
@@ -20,6 +20,7 @@
 package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
 
 import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization.GraphFilterStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.P;
 import org.apache.tinkerpop.gremlin.process.traversal.Step;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
@@ -29,10 +30,12 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.filter.DedupGlobalSte
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.DropStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.OrStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.RangeGlobalStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.TraversalFilterStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.AbstractTraversalStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
 
@@ -89,6 +92,46 @@ public final class InlineFilterStrategy extends AbstractTraversalStrategy<Traver
                     traversal.removeStep(step);
                 }
             }
+            // or(has(x,y),has(x,z)) --> has(x,y.or(z))
+            for (final OrStep<?> step : TraversalHelper.getStepsOfClass(OrStep.class, traversal)) {
+                boolean process = true;
+                String key = null;
+                P predicate = null;
+                final List<String> labels = new ArrayList<>();
+                for (final Traversal.Admin<?, ?> childTraversal : step.getLocalChildren()) {
+                    this.apply(childTraversal); // todo: this may be a bad idea, but I can't seem to find a test case to break it
+                    for (final Step<?, ?> childStep : childTraversal.getSteps()) {
+                        if (childStep instanceof HasStep) {
+                            for (final HasContainer hasContainer : ((HasStep<?>) childStep).getHasContainers()) {
+                                if (null == key)
+                                    key = hasContainer.getKey();
+                                else if (!hasContainer.getKey().equals(key)) {
+                                    process = false;
+                                    break;
+                                }
+                                predicate = null == predicate ?
+                                        hasContainer.getPredicate() :
+                                        predicate.or(hasContainer.getPredicate());
+                            }
+                            labels.addAll(childStep.getLabels());
+                        } else {
+                            process = false;
+                            break;
+                        }
+                    }
+                    if (!process)
+                        break;
+                }
+                if (process) {
+                    changed = true;
+                    final HasStep hasStep = new HasStep<>(traversal, new HasContainer(key, predicate));
+                    TraversalHelper.replaceStep(step, hasStep, traversal);
+                    TraversalHelper.copyLabels(step, hasStep, false);
+                    for (final String label : labels) {
+                        hasStep.addLabel(label);
+                    }
+                }
+            }
             // and(x,y) --> x.y
             for (final AndStep<?> step : TraversalHelper.getStepsOfClass(AndStep.class, traversal)) {
                 boolean process = true;
@@ -139,6 +182,7 @@ public final class InlineFilterStrategy extends AbstractTraversalStrategy<Traver
                                 TraversalHelper.applySingleLevelStrategies(traversal, matchTraversal, InlineFilterStrategy.class);
                                 step.removeGlobalChild(matchTraversal);
                                 step.getPreviousStep().addLabel(startLabel);
+                                // TODO: matchTraversal.getEndStep().addLabel(startLabel); (perhaps insert an identity so filter rank can push has()-left)
                                 if (null != endLabel) matchTraversal.getEndStep().addLabel(endLabel);
                                 TraversalHelper.insertTraversal((Step) step.getPreviousStep(), matchTraversal, traversal);
                             }
@@ -149,7 +193,6 @@ public final class InlineFilterStrategy extends AbstractTraversalStrategy<Traver
                 }
             }
         }
-
     }
 
     private static final String determineStartLabelForHasPullOut(final MatchStep<?, ?> matchStep) {

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/8eb0fdde/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/AndP.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/AndP.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/AndP.java
index 8a7784f..cb001ff 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/AndP.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/AndP.java
@@ -34,6 +34,9 @@ public final class AndP<V> extends ConnectiveP<V> {
 
     public AndP(final List<P<V>> predicates) {
         super(predicates);
+        for (final P<V> p : predicates) {
+            this.and(p);
+        }
         this.biPredicate = new AndBiPredicate(this);
     }
 
@@ -49,7 +52,10 @@ public final class AndP<V> extends ConnectiveP<V> {
     public P<V> and(final Predicate<? super V> predicate) {
         if (!(predicate instanceof P))
             throw new IllegalArgumentException("Only P predicates can be and'd together");
-        this.predicates.add((P<V>) predicate);   // TODO: clone and add?
+        else if (predicate instanceof AndP)
+            this.predicates.addAll(((AndP) predicate).getPredicates());
+        else
+            this.predicates.add((P<V>) predicate);
         return this;
     }
 

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/8eb0fdde/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/ConnectiveP.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/ConnectiveP.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/ConnectiveP.java
index 70f008a..855fc06 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/ConnectiveP.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/ConnectiveP.java
@@ -31,13 +31,12 @@ import java.util.function.Predicate;
  */
 public abstract class ConnectiveP<V> extends P<V> {
 
-    protected List<P<V>> predicates;
+    protected List<P<V>> predicates = new ArrayList<>();
 
     public ConnectiveP(final List<P<V>> predicates) {
         super(null, null);
         if (predicates.size() < 2)
             throw new IllegalArgumentException("The provided " + this.getClass().getSimpleName() + " array must have at least two arguments: " + predicates.size());
-        this.predicates = new ArrayList<>(predicates); // to avoid Arrays.asList() and unmodifiable exceptions
     }
 
     @Deprecated

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/8eb0fdde/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/OrP.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/OrP.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/OrP.java
index 8bc4387..f7363b4 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/OrP.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/OrP.java
@@ -22,7 +22,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.P;
 import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
 
 import java.io.Serializable;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.function.BiPredicate;
@@ -35,6 +34,9 @@ public final class OrP<V> extends ConnectiveP<V> {
 
     public OrP(final List<P<V>> predicates) {
         super(predicates);
+        for (final P<V> p : predicates) {
+            this.or(p);
+        }
         this.biPredicate = new OrBiPredicate(this);
     }
 
@@ -50,7 +52,10 @@ public final class OrP<V> extends ConnectiveP<V> {
     public P<V> or(final Predicate<? super V> predicate) {
         if (!(predicate instanceof P))
             throw new IllegalArgumentException("Only P predicates can be or'd together");
-        this.predicates.add((P<V>) predicate);   // TODO: clone and add?
+        else if (predicate instanceof OrP)
+            this.predicates.addAll(((OrP) predicate).getPredicates());
+        else
+            this.predicates.add((P<V>) predicate);
         return this;
     }
 

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/8eb0fdde/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/PTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/PTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/PTest.java
index 3810c96..6ec33cc 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/PTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/PTest.java
@@ -19,8 +19,11 @@
 package org.apache.tinkerpop.gremlin.process.traversal;
 
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.util.AndP;
+import org.apache.tinkerpop.gremlin.process.traversal.util.OrP;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
@@ -29,135 +32,157 @@ import java.util.Arrays;
 import java.util.Random;
 import java.util.function.Predicate;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 /**
  * @author Daniel Kuppitz (http://gremlin.guru)
  */
-@RunWith(Parameterized.class)
+@RunWith(Enclosed.class)
 public class PTest {
 
-    @Parameterized.Parameters(name = "{0}.test({1}) = {2}")
-    public static Iterable<Object[]> data() {
-        return new ArrayList<>(Arrays.asList(new Object[][]{
-                {P.eq(0), 0, true},
-                {P.eq(0), 1, false},
-                {P.neq(0), 0, false},
-                {P.neq(0), 1, true},
-                {P.gt(0), -1, false},
-                {P.gt(0), 0, false},
-                {P.gt(0), 1, true},
-                {P.lt(0), -1, true},
-                {P.lt(0), 0, false},
-                {P.lt(0), 1, false},
-                {P.gte(0), -1, false},
-                {P.gte(0), 0, true},
-                {P.gte(0), 1, true},
-                {P.lte(0), -1, true},
-                {P.lte(0), 0, true},
-                {P.lte(0), 1, false},
-                {P.between(1, 10), 0, false},
-                {P.between(1, 10), 1, true},
-                {P.between(1, 10), 9, true},
-                {P.between(1, 10), 10, false},
-                {P.inside(1, 10), 0, false},
-                {P.inside(1, 10), 1, false},
-                {P.inside(1, 10), 9, true},
-                {P.inside(1, 10), 10, false},
-                {P.outside(1, 10), 0, true},
-                {P.outside(1, 10), 1, false},
-                {P.outside(1, 10), 9, false},
-                {P.outside(1, 10), 10, false},
-                {P.within(1, 2, 3), 0, false},
-                {P.within(1, 2, 3), 1, true},
-                {P.within(1, 2, 3), 10, false},
-                {P.within(Arrays.asList(1, 2, 3)), 0, false},
-                {P.within(Arrays.asList(1, 2, 3)), 1, true},
-                {P.within(Arrays.asList(1, 2, 3)), 10, false},
-                {P.without(1, 2, 3), 0, true},
-                {P.without(1, 2, 3), 1, false},
-                {P.without(1, 2, 3), 10, true},
-                {P.without(Arrays.asList(1, 2, 3)), 0, true},
-                {P.without(Arrays.asList(1, 2, 3)), 1, false},
-                {P.without(Arrays.asList(1, 2, 3)), 10, true},
-                {P.between("m", "n").and(P.neq("marko")), "marko", false},
-                {P.between("m", "n").and(P.neq("marko")), "matthias", true},
-                {P.between("m", "n").or(P.eq("daniel")), "marko", true},
-                {P.between("m", "n").or(P.eq("daniel")), "daniel", true},
-                {P.between("m", "n").or(P.eq("daniel")), "stephen", false},
-        }));
-    }
+    @RunWith(Parameterized.class)
+    public static class ParameterizedTest {
+
+        @Parameterized.Parameters(name = "{0}.test({1}) = {2}")
+        public static Iterable<Object[]> data() {
+            return new ArrayList<>(Arrays.asList(new Object[][]{
+                    {P.eq(0), 0, true},
+                    {P.eq(0), 1, false},
+                    {P.neq(0), 0, false},
+                    {P.neq(0), 1, true},
+                    {P.gt(0), -1, false},
+                    {P.gt(0), 0, false},
+                    {P.gt(0), 1, true},
+                    {P.lt(0), -1, true},
+                    {P.lt(0), 0, false},
+                    {P.lt(0), 1, false},
+                    {P.gte(0), -1, false},
+                    {P.gte(0), 0, true},
+                    {P.gte(0), 1, true},
+                    {P.lte(0), -1, true},
+                    {P.lte(0), 0, true},
+                    {P.lte(0), 1, false},
+                    {P.between(1, 10), 0, false},
+                    {P.between(1, 10), 1, true},
+                    {P.between(1, 10), 9, true},
+                    {P.between(1, 10), 10, false},
+                    {P.inside(1, 10), 0, false},
+                    {P.inside(1, 10), 1, false},
+                    {P.inside(1, 10), 9, true},
+                    {P.inside(1, 10), 10, false},
+                    {P.outside(1, 10), 0, true},
+                    {P.outside(1, 10), 1, false},
+                    {P.outside(1, 10), 9, false},
+                    {P.outside(1, 10), 10, false},
+                    {P.within(1, 2, 3), 0, false},
+                    {P.within(1, 2, 3), 1, true},
+                    {P.within(1, 2, 3), 10, false},
+                    {P.within(Arrays.asList(1, 2, 3)), 0, false},
+                    {P.within(Arrays.asList(1, 2, 3)), 1, true},
+                    {P.within(Arrays.asList(1, 2, 3)), 10, false},
+                    {P.without(1, 2, 3), 0, true},
+                    {P.without(1, 2, 3), 1, false},
+                    {P.without(1, 2, 3), 10, true},
+                    {P.without(Arrays.asList(1, 2, 3)), 0, true},
+                    {P.without(Arrays.asList(1, 2, 3)), 1, false},
+                    {P.without(Arrays.asList(1, 2, 3)), 10, true},
+                    {P.between("m", "n").and(P.neq("marko")), "marko", false},
+                    {P.between("m", "n").and(P.neq("marko")), "matthias", true},
+                    {P.between("m", "n").or(P.eq("daniel")), "marko", true},
+                    {P.between("m", "n").or(P.eq("daniel")), "daniel", true},
+                    {P.between("m", "n").or(P.eq("daniel")), "stephen", false},
+            }));
+        }
 
-    @Parameterized.Parameter(value = 0)
-    public P predicate;
+        @Parameterized.Parameter(value = 0)
+        public P predicate;
 
-    @Parameterized.Parameter(value = 1)
-    public Object value;
+        @Parameterized.Parameter(value = 1)
+        public Object value;
 
-    @Parameterized.Parameter(value = 2)
-    public boolean expected;
+        @Parameterized.Parameter(value = 2)
+        public boolean expected;
 
-    @Test
-    public void shouldTest() {
-        assertEquals(expected, predicate.test(value));
-        assertEquals(!expected, predicate.clone().negate().test(value));
-        assertEquals(!expected, P.not(predicate).test(value));
-    }
-
-    @Before
-    public void init() {
-        final Object pv = predicate.getValue();
-        final Random r = new Random();
-        assertNotNull(predicate.getBiPredicate());
-        predicate.setValue(r.nextDouble());
-        assertNotNull(predicate.getValue());
-        predicate.setValue(pv);
-        assertEquals(pv, predicate.getValue());
-        assertNotNull(predicate.hashCode());
-        assertEquals(predicate, predicate.clone());
-        assertNotEquals(__.identity(), predicate);
-
-        boolean thrown = true;
-        try {
-            predicate.and(new CustomPredicate());
-            thrown = false;
-        } catch (IllegalArgumentException ex) {
-            assertEquals("Only P predicates can be and'd together", ex.getMessage());
-        } finally {
-            assertTrue(thrown);
+        @Test
+        public void shouldTest() {
+            assertEquals(expected, predicate.test(value));
+            assertEquals(!expected, predicate.clone().negate().test(value));
+            assertEquals(!expected, P.not(predicate).test(value));
         }
 
-        thrown = true;
-        try {
-            predicate.or(new CustomPredicate());
-            thrown = false;
-        } catch (IllegalArgumentException ex) {
-            assertEquals("Only P predicates can be or'd together", ex.getMessage());
-        } finally {
-            assertTrue(thrown);
+        @Before
+        public void init() {
+            final Object pv = predicate.getValue();
+            final Random r = new Random();
+            assertNotNull(predicate.getBiPredicate());
+            predicate.setValue(r.nextDouble());
+            assertNotNull(predicate.getValue());
+            predicate.setValue(pv);
+            assertEquals(pv, predicate.getValue());
+            assertNotNull(predicate.hashCode());
+            assertEquals(predicate, predicate.clone());
+            assertNotEquals(__.identity(), predicate);
+
+            boolean thrown = true;
+            try {
+                predicate.and(new CustomPredicate());
+                thrown = false;
+            } catch (IllegalArgumentException ex) {
+                assertEquals("Only P predicates can be and'd together", ex.getMessage());
+            } finally {
+                assertTrue(thrown);
+            }
+
+            thrown = true;
+            try {
+                predicate.or(new CustomPredicate());
+                thrown = false;
+            } catch (IllegalArgumentException ex) {
+                assertEquals("Only P predicates can be or'd together", ex.getMessage());
+            } finally {
+                assertTrue(thrown);
+            }
         }
-    }
 
-    private class CustomPredicate implements Predicate {
+        private class CustomPredicate implements Predicate {
 
-        @Override
-        public boolean test(Object o) {
-            return false;
-        }
+            @Override
+            public boolean test(Object o) {
+                return false;
+            }
 
-        @Override
-        public Predicate and(Predicate other) {
-            return null;
-        }
+            @Override
+            public Predicate and(Predicate other) {
+                return null;
+            }
 
-        @Override
-        public Predicate negate() {
-            return null;
+            @Override
+            public Predicate negate() {
+                return null;
+            }
+
+            @Override
+            public Predicate or(Predicate other) {
+                return null;
+            }
         }
+    }
 
-        @Override
-        public Predicate or(Predicate other) {
-            return null;
+    public static class ConnectiveTest {
+
+        @Test
+        public void shouldComposeCorrectly() {
+            assertEquals(P.eq(1), P.eq(1));
+            assertEquals(P.eq(1).and(P.eq(2)), new AndP<>(Arrays.asList(P.eq(1), P.eq(2))));
+            assertEquals(P.eq(1).and(P.eq(2).and(P.eq(3))), new AndP<>(Arrays.asList(P.eq(1), P.eq(2), P.eq(3))));
+            assertEquals(P.eq(1).and(P.eq(2).and(P.eq(3).and(P.eq(4)))), new AndP<>(Arrays.asList(P.eq(1), P.eq(2), P.eq(3), P.eq(4))));
+            assertEquals(P.eq(1).or(P.eq(2).or(P.eq(3).or(P.eq(4)))), new OrP<>(Arrays.asList(P.eq(1), P.eq(2), P.eq(3), P.eq(4))));
+            assertEquals(P.eq(1).or(P.eq(2).and(P.eq(3).or(P.eq(4)))), new OrP<>(Arrays.asList(P.eq(1), new AndP<>(Arrays.asList(P.eq(2), new OrP<>(Arrays.asList(P.eq(3), P.eq(4))))))));
+            assertEquals(P.eq(1).and(P.eq(2).or(P.eq(3).and(P.eq(4)))), new AndP<>(Arrays.asList(P.eq(1), new OrP<>(Arrays.asList(P.eq(2), new AndP<>(Arrays.asList(P.eq(3), P.eq(4))))))));
+            assertEquals(P.eq(1).and(P.eq(2).and(P.eq(3).or(P.eq(4)))), new AndP<>(Arrays.asList(P.eq(1), P.eq(2), new OrP<>(Arrays.asList(P.eq(3), P.eq(4))))));
         }
     }
 }

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/8eb0fdde/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
index aeae593..9530c82 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
@@ -29,6 +29,9 @@ import org.junit.runners.Parameterized;
 
 import java.util.Arrays;
 
+import static org.apache.tinkerpop.gremlin.process.traversal.P.eq;
+import static org.apache.tinkerpop.gremlin.process.traversal.P.gt;
+import static org.apache.tinkerpop.gremlin.process.traversal.P.lt;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.V;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.and;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.as;
@@ -39,6 +42,7 @@ import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.limit;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.map;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.match;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.or;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.out;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.tail;
 import static org.junit.Assert.assertEquals;
@@ -46,6 +50,8 @@ import static org.junit.Assert.assertEquals;
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
  */
+
+
 @RunWith(Parameterized.class)
 public class InlineFilterStrategyTest {
 
@@ -74,9 +80,21 @@ public class InlineFilterStrategyTest {
                 {filter(has("age", P.gt(10)).as("a")), has("age", P.gt(10)).as("a")},
                 {filter(and(has("age", P.gt(10)).as("a"), has("name", "marko"))), has("age", P.gt(10)).as("a").has("name", "marko")},
                 //
+                {or(has("name", "marko"), has("age", 32)), or(has("name", "marko"), has("age", 32))},
+                {or(has("name", "marko"), has("name", "bob")), has("name", eq("marko").or(eq("bob")))},
+                {or(has("name", "marko"), has("name")), or(has("name", "marko"), has("name"))},
+                {or(has("age", 10), and(has("age", gt(20)), has("age", lt(100)))), has("age", eq(10).or(gt(20).and(lt(100))))},
+                {or(has("name", "marko"), filter(has("name", "bob"))), has("name", eq("marko").or(eq("bob")))},
+                {or(has("name", "marko"), filter(or(filter(has("name", "bob")), has("name", "stephen")))), has("name", eq("marko").or(eq("bob").or(eq("stephen"))))},
+                {or(has("name", "marko").as("a"), filter(or(filter(has("name", "bob")).as("b"), has("name", "stephen").as("c")))), has("name", eq("marko").or(eq("bob").or(eq("stephen")))).as("a", "b", "c")},
+                //
                 {and(has("age", P.gt(10)), filter(has("age", 22))), has("age", P.gt(10)).has("age", 22)},
+                {and(has("age", P.gt(10)).as("a"), filter(has("age", 22).as("b")).as("c")).as("d"), has("age", P.gt(10)).as("a").has("age", 22).as("b", "c", "d")},
                 {and(has("age", P.gt(10)).as("a"), and(filter(has("age", 22).as("b")).as("c"), has("name", "marko").as("d"))), has("age", P.gt(10)).as("a").has("age", 22).as("b", "c").has("name", "marko").as("d")},
+                {and(has("age", P.gt(10)).as("a"), and(has("name","stephen").as("b"), has("name", "marko").as("c")).as("d")).as("e"), has("age", P.gt(10)).as("a").has("name","stephen").as("b").has("name","marko").as("c","d","e")},
                 {and(has("age", P.gt(10)), and(out("knows"), has("name", "marko"))), has("age", P.gt(10)).and(out("knows"), has("name", "marko"))},
+                {and(has("age", P.gt(20)), or(has("age", lt(10)), has("age", gt(100)))), has("age", gt(20)).has("age", lt(10).or(gt(100)))},
+                {and(has("age", P.gt(20)).as("a"), or(has("age", lt(10)), has("age", gt(100)).as("b"))), has("age", gt(20)).as("a").has("age", lt(10).or(gt(100))).as("b")},
                 //
                 {V().match(as("a").has("age", 10), as("a").filter(has("name")).as("b")), V().as("a").has("age", 10).match(as("a").has("name").as("b"))},
                 {match(as("a").has("age", 10), as("a").filter(has("name")).as("b")), match(as("a").has("age", 10), as("a").has("name").as("b"))},

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/8eb0fdde/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/strategy/optimization/TinkerGraphStepStrategyTest.java
----------------------------------------------------------------------
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/strategy/optimization/TinkerGraphStepStrategyTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/strategy/optimization/TinkerGraphStepStrategyTest.java
index d2bc0ea..9f97466 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/strategy/optimization/TinkerGraphStepStrategyTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/strategy/optimization/TinkerGraphStepStrategyTest.java
@@ -48,7 +48,6 @@ import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.filter
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.not;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.properties;
-import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.values;
 import static org.junit.Assert.assertEquals;
 
 /**
@@ -111,7 +110,7 @@ public class TinkerGraphStepStrategyTest {
                 {__.V().as("a").dedup().has("name", "marko").or(has("age"), has("age", gt(32))).filter(has("name", "bob")).has("lang", "java"),
                         g_V("name", eq("marko"), "name", eq("bob"), "lang", eq("java")).as("a").or(has("age"), has("age", gt(32))).dedup(), Arrays.asList(InlineFilterStrategy.instance(), FilterRankingStrategy.instance())},
                 {__.V().as("a").dedup().has("name", "marko").or(has("age", 10), has("age", gt(32))).filter(has("name", "bob")).has("lang", "java"),
-                        g_V("name", eq("marko"), "name", eq("bob"), "lang", eq("java")).as("a").or(has("age", 10), has("age", gt(32))).dedup(), TraversalStrategies.GlobalCache.getStrategies(TinkerGraph.class).toList()},
+                        g_V("name", eq("marko"), "age", eq(10).or(gt(32)), "name", eq("bob"), "lang", eq("java")).as("a").dedup(), TraversalStrategies.GlobalCache.getStrategies(TinkerGraph.class).toList()},
                 {__.V().has("name", "marko").or(not(has("age")), has("age", gt(32))).has("name", "bob").has("lang", "java"),
                         g_V("name", eq("marko"), "name", eq("bob"), "lang", eq("java")).or(not(filter(properties("age"))), has("age", gt(32))), TraversalStrategies.GlobalCache.getStrategies(TinkerGraph.class).toList()}
         });


[9/9] tinkerpop git commit: FilterRankStrategy is getting nasty solid at optimizing filters and itself, as a strategy, is now super efficient -- gutting code here and there as I realize that this is just a that.

Posted by ok...@apache.org.
FilterRankStrategy is getting nasty solid at optimizing filters and itself, as a strategy, is now super efficient -- gutting code here and there as I realize that this is just a that.


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/b8a92a30
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/b8a92a30
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/b8a92a30

Branch: refs/heads/master
Commit: b8a92a30df8ce67a437c8484d950437d3a34cbca
Parents: 56de652
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Fri Sep 30 13:42:33 2016 -0600
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Mon Oct 3 08:24:17 2016 -0600

----------------------------------------------------------------------
 .../optimization/FilterRankingStrategy.java     | 43 ++++++++------------
 .../process/traversal/util/TraversalHelper.java | 10 -----
 .../optimization/FilterRankingStrategyTest.java | 11 ++++-
 .../PathRetractionStrategyTest.java             |  3 +-
 4 files changed, 26 insertions(+), 41 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/b8a92a30/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
index 2065ea1..2f8061b 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
@@ -42,7 +42,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.strategy.AbstractTraversal
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
 
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -91,29 +90,24 @@ public final class FilterRankingStrategy extends AbstractTraversalStrategy<Trave
         boolean modified = true;
         while (modified) {
             modified = false;
-            final Set<String> currentLabels = new HashSet<>();
-            for (final Step<?, ?> step : traversal.getSteps()) {
-                if (!step.getLabels().isEmpty()) {
-                    currentLabels.addAll(step.getLabels());
-                    final Step<?, ?> nextStep = step.getNextStep();
-                    if (validFilterStep(nextStep) && !usesLabels(nextStep, currentLabels)) {
-                        TraversalHelper.copyLabels(step, nextStep, true);
-                        modified = true;
-                    }
-                }
-            }
             final List<Step> steps = traversal.getSteps();
-            int prevRank = 0;
-            for (int i = steps.size() - 1; i >= 0; i--) {
-                final Step curr = steps.get(i);
-                final int rank = usesLabels(curr, TraversalHelper.getLabelsUpTo(curr)) ? 0 : getStepRank(curr);
-                if (prevRank > 0 && rank > prevRank) {
-                    final Step next = curr.getNextStep();
-                    traversal.removeStep(next);
-                    traversal.addStep(i, next);
-                    modified = true;
+            for (int i = 0; i < steps.size() - 1; i++) {
+                final Step<?, ?> step = steps.get(i);
+                final Step<?, ?> nextStep = step.getNextStep();
+                if (!usesLabels(nextStep, step.getLabels())) {
+                    final int nextRank = getStepRank(nextStep);
+                    if (nextRank != 0) {
+                        if (!step.getLabels().isEmpty()) {
+                            TraversalHelper.copyLabels(step, nextStep, true);
+                            modified = true;
+                        }
+                        if (getStepRank(step) > nextRank) {
+                            traversal.removeStep(nextStep);
+                            traversal.addStep(i, nextStep);
+                            modified = true;
+                        }
+                    }
                 }
-                prevRank = rank;
             }
         }
     }
@@ -152,11 +146,6 @@ public final class FilterRankingStrategy extends AbstractTraversalStrategy<Trave
             return 0;
     }
 
-
-    private static boolean validFilterStep(final Step<?, ?> step) {
-        return ((step instanceof FilterStep && !(step instanceof LambdaHolder)) || step instanceof OrderGlobalStep);
-    }
-
     private static boolean usesLabels(final Step<?, ?> step, final Set<String> labels) {
         if (step instanceof LambdaHolder)
             return true;

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/b8a92a30/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
index 1fb9fab..87d3479 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
@@ -592,16 +592,6 @@ public final class TraversalHelper {
         }
     }
 
-    public static Set<String> getLabelsUpTo(final Step<?, ?> stopStep) {
-        final Set<String> labels = new HashSet<>();
-        Step<?, ?> step = stopStep.getPreviousStep();
-        while (!(step instanceof EmptyStep)) {
-            labels.addAll(step.getLabels());
-            step = step.getPreviousStep();
-        }
-        return labels;
-    }
-
     public static boolean hasAllStepsOfClass(final Traversal.Admin<?, ?> traversal, final Class<?>... classesToCheck) {
         for (final Step step : traversal.getSteps()) {
             boolean foundInstance = false;

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/b8a92a30/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
index 99e0cab..ff72f8c 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
@@ -21,7 +21,6 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
-import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
 import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
 import org.apache.tinkerpop.gremlin.structure.Graph;
@@ -34,6 +33,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.function.Predicate;
 
+import static org.apache.tinkerpop.gremlin.process.traversal.P.eq;
 import static org.apache.tinkerpop.gremlin.process.traversal.P.neq;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.filter;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
@@ -86,11 +86,18 @@ public class FilterRankingStrategyTest {
                 {__.has("name", "marko").as("a").out().has("age", 32).as("b").where("a", neq("b")), __.has("name", "marko").as("a").out().has("age", 32).as("b").where("a", neq("b")), Collections.emptyList()},
                 {__.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a"), __.has("name", "marko").has("age", 32).has("name", "bob").dedup().as("a"), Collections.emptyList()},
                 {__.has("name", "marko").dedup().as("a").has("age", 32).has("name", "bob").as("b"), __.has("name", "marko").has("age", 32).has("name", "bob").dedup().as("b", "a"), Collections.emptyList()},
+                {__.where("b", eq("c")).as("a").dedup("a").has("name", "marko"), __.has("name", "marko").where("b", eq("c")).as("a").dedup("a"), Collections.emptyList()},
+                {__.where("b", eq("c")).has("name", "bob").as("a").dedup("a").has("name", "marko"), __.has("name", "bob").has("name", "marko").where("b", eq("c")).as("a").dedup("a"), Collections.emptyList()},
+                {__.has("name","marko").as("a").out().has("name","bob").dedup().as("b").where(__.as("a").out().as("b")),__.has("name","marko").as("a").out().has("name","bob").dedup().as("b").where(__.as("a").out().as("b")),Collections.emptyList()},
+                {__.has("name","marko").as("a").out().has("name","bob").as("b").dedup().where(__.as("a").out().as("b")),__.has("name","marko").as("a").out().has("name","bob").dedup().as("b").where(__.as("a").out().as("b")),Collections.emptyList()},
+                {__.has("name","marko").as("a").out().has("name","bob").dedup().as("c").where(__.as("a").out().as("b")),__.has("name","marko").as("a").out().has("name","bob").where(__.as("a").out().as("b")).dedup().as("c"),Collections.emptyList()},
                 {__.order().dedup(), __.dedup().order(), Collections.emptyList()},
                 {__.order().filter(testP).dedup(), __.order().filter(testP).dedup(), Collections.emptyList()},
                 {__.order().as("a").dedup(), __.dedup().order().as("a"), Collections.emptyList()},
                 {__.order().as("a").dedup("a"), __.order().as("a").dedup("a"), Collections.emptyList()},
-                // {__.order().as("a").dedup("a").has("name","marko"), __.has("name","marko").order().as("a").dedup("a"), Collections.emptyList()},
+                {__.order().as("a").dedup("a").has("name", "marko"), __.has("name", "marko").as("a").dedup("a").order(), Collections.emptyList()},
+                {__.order().as("a").dedup("a").has("name", "marko").out(), __.has("name", "marko").as("a").dedup("a").order().out(), Collections.emptyList()},
+                {__.order().as("a").dedup("a").has("name", "marko").where("a", eq("b")).out(), __.has("name", "marko").as("a").where("a", eq("b")).dedup("a").order().out(), Collections.emptyList()},
                 {__.identity().order().dedup(), __.dedup().order(), Collections.singletonList(IdentityRemovalStrategy.instance())},
                 {__.order().identity().dedup(), __.dedup().order(), Collections.singletonList(IdentityRemovalStrategy.instance())},
                 {__.order().out().dedup(), __.order().out().dedup(), Collections.emptyList()},

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/b8a92a30/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java
index 0063289..e95c729 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/PathRetractionStrategyTest.java
@@ -60,8 +60,7 @@ public class PathRetractionStrategyTest {
             new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance()),
             new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance(), PathProcessorStrategy.instance()),
             new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance(), PathProcessorStrategy.instance(), MatchPredicateStrategy.instance()),
-            new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance(), PathProcessorStrategy.instance(), MatchPredicateStrategy.instance(), RepeatUnrollStrategy.instance()),
-            TraversalStrategies.GlobalCache.getStrategies(Graph.class));
+            new DefaultTraversalStrategies().addStrategies(PathRetractionStrategy.instance(), PathProcessorStrategy.instance(), MatchPredicateStrategy.instance(), RepeatUnrollStrategy.instance()));
 
     @Parameterized.Parameter(value = 0)
     public Traversal.Admin traversal;


[7/9] tinkerpop git commit: FilterRankStrategy now is smart about Scoping steps and thus, can rank labeled steps. order().as('a').dedup() is dedup().order().as('a'), but order().as('a').dedup('a') is order().as('a').dedup('a'). Lots of test cases in Filt

Posted by ok...@apache.org.
FilterRankStrategy now is smart about Scoping steps and thus, can rank labeled steps. order().as('a').dedup() is dedup().order().as('a'), but order().as('a').dedup('a') is order().as('a').dedup('a'). Lots of test cases in FilterRankStrategyTest updated with more efficient reordering.


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/56de6529
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/56de6529
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/56de6529

Branch: refs/heads/master
Commit: 56de6529f2c5c59b83ff34d0190788a0ccfaf17c
Parents: 68bbae1
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Fri Sep 30 10:36:23 2016 -0600
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Mon Oct 3 08:24:17 2016 -0600

----------------------------------------------------------------------
 .../optimization/FilterRankingStrategy.java     | 86 ++++++++------------
 .../process/traversal/util/TraversalHelper.java | 20 +++++
 .../optimization/FilterRankingStrategyTest.java | 15 ++--
 .../TinkerGraphStepStrategyTest.java            | 10 +--
 4 files changed, 68 insertions(+), 63 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/56de6529/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
index 06726b1..2065ea1 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
@@ -22,6 +22,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.Step;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.step.LambdaHolder;
+import org.apache.tinkerpop.gremlin.process.traversal.step.Scoping;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.AndStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.ClassFilterStep;
@@ -39,17 +40,16 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.filter.WhereTraversal
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderGlobalStep;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.AbstractTraversalStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
-import org.apache.tinkerpop.gremlin.structure.Graph;
-import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 
 import java.util.Collections;
-import java.util.Iterator;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 /**
- * FilterRankingStrategy reorders filter- and order-steps according to their rank. Labeled steps or lambda holders or
- * steps that contain child traversals, that have labeled steps or lambda holders, will not be reordered.
+ * FilterRankingStrategy reorders filter- and order-steps according to their rank. It will also do its best to push
+ * step labels as far "right" as possible in order to keep traversers as small and bulkable as possible prior to the
+ * absolute need for path-labeling.
  * <p/>
  * <table>
  * <thead>
@@ -89,12 +89,14 @@ public final class FilterRankingStrategy extends AbstractTraversalStrategy<Trave
     @Override
     public void apply(final Traversal.Admin<?, ?> traversal) {
         boolean modified = true;
-        while(modified) {
+        while (modified) {
             modified = false;
+            final Set<String> currentLabels = new HashSet<>();
             for (final Step<?, ?> step : traversal.getSteps()) {
-                if (step instanceof FilterStep && !step.getLabels().isEmpty()) {
+                if (!step.getLabels().isEmpty()) {
+                    currentLabels.addAll(step.getLabels());
                     final Step<?, ?> nextStep = step.getNextStep();
-                    if (nextStep instanceof FilterStep && !(nextStep instanceof TraversalParent)) {
+                    if (validFilterStep(nextStep) && !usesLabels(nextStep, currentLabels)) {
                         TraversalHelper.copyLabels(step, nextStep, true);
                         modified = true;
                     }
@@ -104,7 +106,7 @@ public final class FilterRankingStrategy extends AbstractTraversalStrategy<Trave
             int prevRank = 0;
             for (int i = steps.size() - 1; i >= 0; i--) {
                 final Step curr = steps.get(i);
-                final int rank = rank(curr);
+                final int rank = usesLabels(curr, TraversalHelper.getLabelsUpTo(curr)) ? 0 : getStepRank(curr);
                 if (prevRank > 0 && rank > prevRank) {
                     final Step next = curr.getNextStep();
                     traversal.removeStep(next);
@@ -116,15 +118,6 @@ public final class FilterRankingStrategy extends AbstractTraversalStrategy<Trave
         }
     }
 
-    @Override
-    public Set<Class<? extends OptimizationStrategy>> applyPrior() {
-        return PRIORS;
-    }
-
-    public static FilterRankingStrategy instance() {
-        return INSTANCE;
-    }
-
     /**
      * Ranks the given step. Steps with lower ranks can be moved in front of steps with higher ranks. 0 means that
      * the step has no rank and thus is not exchangeable with its neighbors.
@@ -159,47 +152,34 @@ public final class FilterRankingStrategy extends AbstractTraversalStrategy<Trave
             return 0;
     }
 
-    /**
-     * If the given step has no child traversal that holds a lambda, then the actual rank determined by
-     * {@link #getStepRank(Step)} is returned, otherwise 0.
-     *
-     * @param step the step to get a ranking for
-     * @return The rank of the given step.
-     */
-    private static int rank(final Step step) {
-        if (isNotOptimizableStep(step)) {
-            return 0;
-        }
-        final int rank = getStepRank(step);
-        if (rank > 0 && step instanceof TraversalParent) {
-            final TraversalParent tp = (TraversalParent) step;
-            final Iterator<Traversal.Admin<Object, Object>> childTraversalIterator = IteratorUtils.concat(
-                    tp.getLocalChildren().iterator(), tp.getGlobalChildren().iterator());
-            while (childTraversalIterator.hasNext()) {
-                if (TraversalHelper.anyStepRecursively(FilterRankingStrategy::isNotOptimizableStep, childTraversalIterator.next())) {
-                    return 0;
-                }
-            }
-        }
-        return rank;
+
+    private static boolean validFilterStep(final Step<?, ?> step) {
+        return ((step instanceof FilterStep && !(step instanceof LambdaHolder)) || step instanceof OrderGlobalStep);
     }
 
-    /**
-     * Returns true if the step is not optimizable, otherwise false. A step is not optimizable if it (or any of its
-     * child traversals) is a lambda holder or has a label.
-     *
-     * @param step the step to check for optimizability
-     * @return true if the given step is optimizable, otherwise false.
-     */
-    private static boolean isNotOptimizableStep(final Step<?, ?> step) {
+    private static boolean usesLabels(final Step<?, ?> step, final Set<String> labels) {
         if (step instanceof LambdaHolder)
             return true;
-        else {
-            for (final String label : step.getLabels()) {
-                if (!Graph.Hidden.isHidden(label))
+        if (step instanceof Scoping) {
+            final Set<String> scopes = ((Scoping) step).getScopeKeys();
+            for (final String label : labels) {
+                if (scopes.contains(label))
                     return true;
             }
-            return false;
         }
+        if (step instanceof TraversalParent) {
+            if (TraversalHelper.anyStepRecursively(s -> usesLabels(s, labels), (TraversalParent) step))
+                return true;
+        }
+        return false;
+    }
+
+    @Override
+    public Set<Class<? extends OptimizationStrategy>> applyPrior() {
+        return PRIORS;
+    }
+
+    public static FilterRankingStrategy instance() {
+        return INSTANCE;
     }
 }

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/56de6529/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
index be1406d..1fb9fab 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
@@ -425,6 +425,16 @@ public final class TraversalHelper {
         return false;
     }
 
+    public static boolean anyStepRecursively(final Predicate<Step> predicate, final TraversalParent step) {
+        for (final Traversal.Admin<?, ?> localChild : step.getLocalChildren()) {
+            if (anyStepRecursively(predicate, localChild)) return true;
+        }
+        for (final Traversal.Admin<?, ?> globalChild : step.getGlobalChildren()) {
+            if (anyStepRecursively(predicate, globalChild)) return true;
+        }
+        return false;
+    }
+
     public static <S> void addToCollection(final Collection<S> collection, final S s, final long bulk) {
         if (collection instanceof BulkSet) {
             ((BulkSet<S>) collection).add(s, bulk);
@@ -582,6 +592,16 @@ public final class TraversalHelper {
         }
     }
 
+    public static Set<String> getLabelsUpTo(final Step<?, ?> stopStep) {
+        final Set<String> labels = new HashSet<>();
+        Step<?, ?> step = stopStep.getPreviousStep();
+        while (!(step instanceof EmptyStep)) {
+            labels.addAll(step.getLabels());
+            step = step.getPreviousStep();
+        }
+        return labels;
+    }
+
     public static boolean hasAllStepsOfClass(final Traversal.Admin<?, ?> traversal, final Class<?>... classesToCheck) {
         for (final Step step : traversal.getSteps()) {
             boolean foundInstance = false;

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/56de6529/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
index bd12e34..99e0cab 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
@@ -21,6 +21,7 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
 import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
 import org.apache.tinkerpop.gremlin.structure.Graph;
@@ -31,6 +32,7 @@ import org.junit.runners.Parameterized;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.function.Predicate;
 
 import static org.apache.tinkerpop.gremlin.process.traversal.P.neq;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.filter;
@@ -77,15 +79,18 @@ public class FilterRankingStrategyTest {
 
     @Parameterized.Parameters(name = "{0}")
     public static Iterable<Object[]> generateTestParameters() {
-
+        final Predicate testP = t -> true;
         return Arrays.asList(new Object[][]{
                 {__.dedup().order(), __.dedup().order(), Collections.emptyList()},
-                {__.has("name", "marko").as("a").out().as("b").has("age", 32).where("a", neq("b")), __.has("name", "marko").as("a").out().as("b").has("age", 32).where("a", neq("b")), Collections.emptyList()},
+                {__.has("name", "marko").as("a").out().as("b").has("age", 32).where("a", neq("b")).as("c").out(), __.has("name", "marko").as("a").out().has("age", 32).as("b").where("a", neq("b")).as("c").out(), Collections.emptyList()},
                 {__.has("name", "marko").as("a").out().has("age", 32).as("b").where("a", neq("b")), __.has("name", "marko").as("a").out().has("age", 32).as("b").where("a", neq("b")), Collections.emptyList()},
-                {__.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a"), __.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a"), Collections.emptyList()},
-                {__.has("name", "marko").dedup().as("a").has("age", 32).has("name", "bob").as("b"), __.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a", "b"), Collections.emptyList()},
+                {__.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a"), __.has("name", "marko").has("age", 32).has("name", "bob").dedup().as("a"), Collections.emptyList()},
+                {__.has("name", "marko").dedup().as("a").has("age", 32).has("name", "bob").as("b"), __.has("name", "marko").has("age", 32).has("name", "bob").dedup().as("b", "a"), Collections.emptyList()},
                 {__.order().dedup(), __.dedup().order(), Collections.emptyList()},
-                {__.order().as("a").dedup(), __.order().as("a").dedup(), Collections.emptyList()},
+                {__.order().filter(testP).dedup(), __.order().filter(testP).dedup(), Collections.emptyList()},
+                {__.order().as("a").dedup(), __.dedup().order().as("a"), Collections.emptyList()},
+                {__.order().as("a").dedup("a"), __.order().as("a").dedup("a"), Collections.emptyList()},
+                // {__.order().as("a").dedup("a").has("name","marko"), __.has("name","marko").order().as("a").dedup("a"), Collections.emptyList()},
                 {__.identity().order().dedup(), __.dedup().order(), Collections.singletonList(IdentityRemovalStrategy.instance())},
                 {__.order().identity().dedup(), __.dedup().order(), Collections.singletonList(IdentityRemovalStrategy.instance())},
                 {__.order().out().dedup(), __.order().out().dedup(), Collections.emptyList()},

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/56de6529/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/strategy/optimization/TinkerGraphStepStrategyTest.java
----------------------------------------------------------------------
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/strategy/optimization/TinkerGraphStepStrategyTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/strategy/optimization/TinkerGraphStepStrategyTest.java
index 9f97466..35f936c 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/strategy/optimization/TinkerGraphStepStrategyTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/strategy/optimization/TinkerGraphStepStrategyTest.java
@@ -100,17 +100,17 @@ public class TinkerGraphStepStrategyTest {
                 {__.V().has("name", "marko").as("a").or(has("age"), has("age", gt(32))).has("lang", "java"),
                         g_V("name", eq("marko")).as("a").or(has("age"), has("age", gt(32))).has("lang", "java"), Collections.emptyList()},
                 {__.V().has("name", "marko").as("a").or(has("age"), has("age", gt(32))).has("lang", "java"),
-                        g_V("name", eq("marko"), "lang", eq("java")).as("a").or(has("age"), has("age", gt(32))), Collections.singletonList(FilterRankingStrategy.instance())},
+                        g_V("name", eq("marko"), "lang", eq("java")).or(has("age"), has("age", gt(32))).as("a"), Collections.singletonList(FilterRankingStrategy.instance())},
                 {__.V().dedup().has("name", "marko").or(has("age"), has("age", gt(32))).has("lang", "java"),
                         g_V("name", eq("marko"), "lang", eq("java")).or(has("age"), has("age", gt(32))).dedup(), Collections.singletonList(FilterRankingStrategy.instance())},
                 {__.V().as("a").dedup().has("name", "marko").or(has("age"), has("age", gt(32))).has("lang", "java"),
-                        g_V("name", eq("marko"), "lang", eq("java")).as("a").or(has("age"), has("age", gt(32))).dedup(), Collections.singletonList(FilterRankingStrategy.instance())},
+                        g_V("name", eq("marko"), "lang", eq("java")).or(has("age"), has("age", gt(32))).dedup().as("a"), Collections.singletonList(FilterRankingStrategy.instance())},
                 {__.V().as("a").has("name", "marko").as("b").or(has("age"), has("age", gt(32))).has("lang", "java"),
-                        g_V("name", eq("marko"), "lang", eq("java")).as("a", "b").or(has("age"), has("age", gt(32))), Collections.singletonList(FilterRankingStrategy.instance())},
+                        g_V("name", eq("marko"), "lang", eq("java")).or(has("age"), has("age", gt(32))).as("b", "a"), Collections.singletonList(FilterRankingStrategy.instance())},
                 {__.V().as("a").dedup().has("name", "marko").or(has("age"), has("age", gt(32))).filter(has("name", "bob")).has("lang", "java"),
-                        g_V("name", eq("marko"), "name", eq("bob"), "lang", eq("java")).as("a").or(has("age"), has("age", gt(32))).dedup(), Arrays.asList(InlineFilterStrategy.instance(), FilterRankingStrategy.instance())},
+                        g_V("name", eq("marko"), "name", eq("bob"), "lang", eq("java")).or(has("age"), has("age", gt(32))).dedup().as("a"), Arrays.asList(InlineFilterStrategy.instance(), FilterRankingStrategy.instance())},
                 {__.V().as("a").dedup().has("name", "marko").or(has("age", 10), has("age", gt(32))).filter(has("name", "bob")).has("lang", "java"),
-                        g_V("name", eq("marko"), "age", eq(10).or(gt(32)), "name", eq("bob"), "lang", eq("java")).as("a").dedup(), TraversalStrategies.GlobalCache.getStrategies(TinkerGraph.class).toList()},
+                        g_V("name", eq("marko"), "age", eq(10).or(gt(32)), "name", eq("bob"), "lang", eq("java")).dedup().as("a"), TraversalStrategies.GlobalCache.getStrategies(TinkerGraph.class).toList()},
                 {__.V().has("name", "marko").or(not(has("age")), has("age", gt(32))).has("name", "bob").has("lang", "java"),
                         g_V("name", eq("marko"), "name", eq("bob"), "lang", eq("java")).or(not(filter(properties("age"))), has("age", gt(32))), TraversalStrategies.GlobalCache.getStrategies(TinkerGraph.class).toList()}
         });


[3/9] tinkerpop git commit: FilterRankStategy is now smart about pushing labels 'right'. Why is this good -- it ensures that filter-chains are as concatenated as possible without changing path semantics. This is about increasing the number of potential h

Posted by ok...@apache.org.
FilterRankStategy is now smart about pushing labels 'right'. Why is this good -- it ensures that filter-chains are as concatenated as possible without changing path semantics. This is about increasing the number of potential has()-steps that providers can grab for index lookups. Also, InlineFilterStep is is able to compress has().has() chains into a single has() and propagate labels accordingly. Added various test cases to validate behavior. The only thing left is HasContainer being able to compress AndP predicates and we will have a really tight compression on filters.


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/ff1c3844
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/ff1c3844
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/ff1c3844

Branch: refs/heads/master
Commit: ff1c3844a487cf4db437edfdf7f2251c38da50ab
Parents: 9ef8a9a
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Thu Sep 29 14:42:51 2016 -0600
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Mon Oct 3 08:24:17 2016 -0600

----------------------------------------------------------------------
 CHANGELOG.asciidoc                              |  1 +
 .../optimization/FilterRankingStrategy.java     | 16 ++++++--
 .../optimization/InlineFilterStrategy.java      | 18 ++++++++-
 .../process/traversal/util/TraversalHelper.java | 11 ++++--
 .../decoration/SubgraphStrategyTest.java        | 28 +++++++-------
 .../optimization/FilterRankingStrategyTest.java |  3 ++
 .../optimization/InlineFilterStrategyTest.java  | 39 +++++++++++++-------
 7 files changed, 79 insertions(+), 37 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/ff1c3844/CHANGELOG.asciidoc
----------------------------------------------------------------------
diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index d204b44..638a80c 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -26,6 +26,7 @@ image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
 TinkerPop 3.2.3 (Release Date: NOT OFFICIALLY RELEASED YET)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+* `FilterRankStrategy` now propagates labels "right" across non-`TraversalParent` filters.
 * Fixed a bug in `ConnectiveP` where nested equivalent connectives should be inlined.
 * Fixed a bug in `IncidentToAdjacentStrategy` where `TreeStep` traversals were allowed.
 * Fixed a end-step label bug in `MatchPredicateStrategy`.

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/ff1c3844/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
index 2a0a025..dead668 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
@@ -43,7 +43,6 @@ import org.apache.tinkerpop.gremlin.structure.Graph;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
@@ -89,9 +88,18 @@ public final class FilterRankingStrategy extends AbstractTraversalStrategy<Trave
 
     @Override
     public void apply(final Traversal.Admin<?, ?> traversal) {
-        boolean modified;
-        do {
+        boolean modified = true;
+        while(modified) {
             modified = false;
+            for (final Step<?, ?> step : traversal.getSteps()) {
+                if (!step.getLabels().isEmpty()) {
+                    final Step<?, ?> nextStep = step.getNextStep();
+                    if (nextStep instanceof FilterStep && !(nextStep instanceof TraversalParent)) {
+                        TraversalHelper.copyLabels(step, nextStep, true);
+                        modified = true;
+                    }
+                }
+            }
             final List<Step> steps = traversal.getSteps();
             int prevRank = 0;
             for (int i = steps.size() - 1; i >= 0; i--) {
@@ -105,7 +113,7 @@ public final class FilterRankingStrategy extends AbstractTraversalStrategy<Trave
                 }
                 prevRank = rank;
             }
-        } while (modified);
+        }
     }
 
     @Override

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/ff1c3844/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
index a3ed9a1..820143a 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
@@ -76,7 +76,10 @@ public final class InlineFilterStrategy extends AbstractTraversalStrategy<Traver
         while (changed) {
             changed = false;
             for (final FilterStep<?> step : TraversalHelper.getStepsOfAssignableClass(FilterStep.class, traversal)) {
-                if (step instanceof TraversalFilterStep && InlineFilterStrategy.processTraversalFilterStep((TraversalFilterStep) step, traversal))
+                if (step instanceof HasStep && InlineFilterStrategy.processHasStep((HasStep) step, traversal))
+                    // has(a,b).has(c) --> has(a,b,c)
+                    changed = true;
+                else if (step instanceof TraversalFilterStep && InlineFilterStrategy.processTraversalFilterStep((TraversalFilterStep) step, traversal))
                     // filter(x.y) --> x.y
                     changed = true;
                 else if (step instanceof OrStep && InlineFilterStrategy.processOrStep((OrStep) step, traversal))
@@ -99,6 +102,19 @@ public final class InlineFilterStrategy extends AbstractTraversalStrategy<Traver
     ////////////////////////////
     ///////////////////////////
 
+    private static final boolean processHasStep(final HasStep<?> step, final Traversal.Admin<?, ?> traversal) {
+        if (step.getPreviousStep() instanceof HasStep) {
+            final HasStep<?> previousStep = (HasStep<?>) step.getPreviousStep();
+            for (final HasContainer hasContainer : step.getHasContainers()) {
+                previousStep.addHasContainer(hasContainer);
+            }
+            TraversalHelper.copyLabels(step, previousStep, false);
+            traversal.removeStep(step);
+            return true;
+        }
+        return false;
+    }
+
     private static final boolean processTraversalFilterStep(final TraversalFilterStep<?> step, final Traversal.Admin<?, ?> traversal) {
         final Traversal.Admin<?, ?> childTraversal = step.getLocalChildren().get(0);
         if (TraversalHelper.hasAllStepsOfClass(childTraversal, FilterStep.class) &&

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/ff1c3844/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
index 2192666..be1406d 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/util/TraversalHelper.java
@@ -50,6 +50,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
@@ -572,10 +573,12 @@ public final class TraversalHelper {
     }
 
     public static void copyLabels(final Step<?, ?> fromStep, final Step<?, ?> toStep, final boolean moveLabels) {
-        for (final String label : fromStep.getLabels()) {
-            toStep.addLabel(label);
-            if (moveLabels)
-                fromStep.removeLabel(label);
+        if (!fromStep.getLabels().isEmpty()) {
+            for (final String label : moveLabels ? new LinkedHashSet<>(fromStep.getLabels()) : fromStep.getLabels()) {
+                toStep.addLabel(label);
+                if (moveLabels)
+                    fromStep.removeLabel(label);
+            }
         }
     }
 

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/ff1c3844/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
index 7082838..901d3a5 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
@@ -69,28 +69,26 @@ public class SubgraphStrategyTest {
         @Parameterized.Parameter(value = 1)
         public Traversal optimized;
 
-
-        void applySubgraphStrategyTest(final Traversal traversal) {
-            final TraversalStrategies strategies = new DefaultTraversalStrategies();
-            strategies.addStrategies(SubgraphStrategy.build().
+        @Test
+        public void doTest() {
+            final TraversalStrategies originalStrategies = new DefaultTraversalStrategies();
+            originalStrategies.addStrategies(SubgraphStrategy.build().
                     vertices(__.and(has("name", "marko"), has("age", 29))).
                     edges(hasLabel("knows")).
                     vertexProperties(__.<VertexProperty, Long>values().count().and(is(P.lt(10)), is(0))).create());
-            strategies.addStrategies(InlineFilterStrategy.instance());
-            strategies.addStrategies(StandardVerificationStrategy.instance());
-            traversal.asAdmin().setStrategies(strategies);
-            traversal.asAdmin().applyStrategies();
-        }
-
-        @Test
-        public void doTest() {
-            applySubgraphStrategyTest(original);
-            assertEquals(optimized, original);
+            originalStrategies.addStrategies(InlineFilterStrategy.instance());
+            originalStrategies.addStrategies(StandardVerificationStrategy.instance());
+            this.original.asAdmin().setStrategies(originalStrategies);
+            this.original.asAdmin().applyStrategies();
+            final TraversalStrategies optimizedStrategies = new DefaultTraversalStrategies();
+            optimizedStrategies.addStrategies(InlineFilterStrategy.instance());
+            this.optimized.asAdmin().setStrategies(optimizedStrategies);
+            this.optimized.asAdmin().applyStrategies();
+            assertEquals(this.optimized, this.original);
         }
 
         @Parameterized.Parameters(name = "{0}")
         public static Iterable<Object[]> generateTestParameters() {
-
             return Arrays.asList(new Traversal[][]{
                     {__.outE(), __.outE().hasLabel("knows").and(
                             inV().has("name", "marko").has("age", 29),

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/ff1c3844/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
index dc0d17a..52379fd 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
@@ -32,6 +32,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 
+import static org.apache.tinkerpop.gremlin.process.traversal.P.eq;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.filter;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.in;
@@ -79,6 +80,8 @@ public class FilterRankingStrategyTest {
 
         return Arrays.asList(new Object[][]{
                 {__.dedup().order(), __.dedup().order(), Collections.emptyList()},
+                {__.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a"), __.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a"), Collections.emptyList()},
+                {__.has("name", "marko").dedup().as("a").has("age", 32).has("name", "bob").as("b"), __.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a","b"), Collections.emptyList()},
                 {__.order().dedup(), __.dedup().order(), Collections.emptyList()},
                 {__.order().as("a").dedup(), __.order().as("a").dedup(), Collections.emptyList()},
                 {__.identity().order().dedup(), __.dedup().order(), Collections.singletonList(IdentityRemovalStrategy.instance())},

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/ff1c3844/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
index 9530c82..abf1f00 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategyTest.java
@@ -22,6 +22,10 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization;
 import org.apache.tinkerpop.gremlin.process.traversal.P;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer;
 import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversalStrategies;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -40,7 +44,6 @@ import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.drop;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.filter;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.limit;
-import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.map;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.match;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.or;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.out;
@@ -74,11 +77,13 @@ public class InlineFilterStrategyTest {
     public static Iterable<Object[]> generateTestParameters() {
 
         return Arrays.asList(new Traversal[][]{
+                {has("age", 10).as("a").has("name", "marko").as("b").coin(0.5).as("c"), addHas(__.start(), "age", eq(10), "name", eq("marko")).as("a","b").coin(0.5).as("c")},
+                //
                 {filter(out("knows")), filter(out("knows"))},
-                {filter(has("age", P.gt(10))).as("a"), has("age", P.gt(10)).as("a")},
-                {filter(has("age", P.gt(10)).as("b")).as("a"), has("age", P.gt(10)).as("b", "a")},
-                {filter(has("age", P.gt(10)).as("a")), has("age", P.gt(10)).as("a")},
-                {filter(and(has("age", P.gt(10)).as("a"), has("name", "marko"))), has("age", P.gt(10)).as("a").has("name", "marko")},
+                {filter(has("age", gt(10))).as("a"), has("age", gt(10)).as("a")},
+                {filter(has("age", gt(10)).as("b")).as("a"), has("age", gt(10)).as("b", "a")},
+                {filter(has("age", gt(10)).as("a")), has("age", gt(10)).as("a")},
+                {filter(and(has("age", gt(10)).as("a"), has("name", "marko"))), addHas(__.start(), "age", gt(10), "name", eq("marko")).as("a")},
                 //
                 {or(has("name", "marko"), has("age", 32)), or(has("name", "marko"), has("age", 32))},
                 {or(has("name", "marko"), has("name", "bob")), has("name", eq("marko").or(eq("bob")))},
@@ -88,17 +93,17 @@ public class InlineFilterStrategyTest {
                 {or(has("name", "marko"), filter(or(filter(has("name", "bob")), has("name", "stephen")))), has("name", eq("marko").or(eq("bob").or(eq("stephen"))))},
                 {or(has("name", "marko").as("a"), filter(or(filter(has("name", "bob")).as("b"), has("name", "stephen").as("c")))), has("name", eq("marko").or(eq("bob").or(eq("stephen")))).as("a", "b", "c")},
                 //
-                {and(has("age", P.gt(10)), filter(has("age", 22))), has("age", P.gt(10)).has("age", 22)},
-                {and(has("age", P.gt(10)).as("a"), filter(has("age", 22).as("b")).as("c")).as("d"), has("age", P.gt(10)).as("a").has("age", 22).as("b", "c", "d")},
-                {and(has("age", P.gt(10)).as("a"), and(filter(has("age", 22).as("b")).as("c"), has("name", "marko").as("d"))), has("age", P.gt(10)).as("a").has("age", 22).as("b", "c").has("name", "marko").as("d")},
-                {and(has("age", P.gt(10)).as("a"), and(has("name","stephen").as("b"), has("name", "marko").as("c")).as("d")).as("e"), has("age", P.gt(10)).as("a").has("name","stephen").as("b").has("name","marko").as("c","d","e")},
-                {and(has("age", P.gt(10)), and(out("knows"), has("name", "marko"))), has("age", P.gt(10)).and(out("knows"), has("name", "marko"))},
-                {and(has("age", P.gt(20)), or(has("age", lt(10)), has("age", gt(100)))), has("age", gt(20)).has("age", lt(10).or(gt(100)))},
-                {and(has("age", P.gt(20)).as("a"), or(has("age", lt(10)), has("age", gt(100)).as("b"))), has("age", gt(20)).as("a").has("age", lt(10).or(gt(100))).as("b")},
+                {and(has("age", gt(10)), filter(has("age", 22))), addHas(__.start(), "age", gt(10), "age", eq(22))},
+                {and(has("age", gt(10)).as("a"), filter(has("age", 22).as("b")).as("c")).as("d"), addHas(__.start(), "age", gt(10), "age", eq(22)).as("a", "b", "c", "d")},
+                {and(has("age", gt(10)).as("a"), and(filter(has("age", 22).as("b")).as("c"), has("name", "marko").as("d"))), addHas(__.start(), "age", gt(10), "age", eq(22), "name", eq("marko")).as("a", "b", "c", "d")},
+                {and(has("age", gt(10)).as("a"), and(has("name", "stephen").as("b"), has("name", "marko").as("c")).as("d")).as("e"), addHas(__.start(), "age", gt(10), "name", eq("stephen"), "name", eq("marko")).as("a", "b", "c", "d", "e")},
+                {and(has("age", gt(10)), and(out("knows"), has("name", "marko"))), has("age", gt(10)).and(out("knows"), has("name", "marko"))},
+                {and(has("age", gt(20)), or(has("age", lt(10)), has("age", gt(100)))), addHas(__.start(), "age", gt(20), "age", lt(10).or(gt(100)))},
+                {and(has("age", gt(20)).as("a"), or(has("age", lt(10)), has("age", gt(100)).as("b"))), addHas(__.start(), "age", gt(20), "age", lt(10).or(gt(100))).as("a", "b")},
                 //
                 {V().match(as("a").has("age", 10), as("a").filter(has("name")).as("b")), V().as("a").has("age", 10).match(as("a").has("name").as("b"))},
                 {match(as("a").has("age", 10), as("a").filter(has("name")).as("b")), match(as("a").has("age", 10), as("a").has("name").as("b"))},
-                {map(match(as("a").has("age", 10), as("a").filter(has("name")).as("b"))), map(match(as("a").has("age", 10), as("a").has("name").as("b")))},
+                {__.map(match(as("a").has("age", 10), as("a").filter(has("name")).as("b"))), __.map(match(as("a").has("age", 10), as("a").has("name").as("b")))},
                 {V().match(as("a").has("age", 10)), V().as("a").has("age", 10)},
                 {V().match(as("a").has("age", 10).as("b"), as("a").filter(has("name")).as("b")), V().as("a").has("age", 10).as("b").match(as("a").has("name").as("b"))},
                 //
@@ -108,4 +113,12 @@ public class InlineFilterStrategyTest {
                 {filter(tail(10).as("a")), filter(tail(10).as("a"))},
         });
     }
+
+    private static GraphTraversal.Admin<?, ?> addHas(final GraphTraversal<?, ?> traversal, final Object... hasKeyValues) {
+        final HasStep<?> hasStep = new HasStep<>((Traversal.Admin) traversal);
+        for (int i = 0; i < hasKeyValues.length; i = i + 2) {
+            hasStep.addHasContainer(new HasContainer((String) hasKeyValues[i], (P) hasKeyValues[i + 1]));
+        }
+        return traversal.asAdmin().addStep(hasStep);
+    }
 }


[6/9] tinkerpop git commit: cleaned up InlineFilterStrategy. Processing methods for step-types introduced. This is not only cleaner, but will allow users/providers to turn on/off InlineFiltering for different step types.

Posted by ok...@apache.org.
cleaned up InlineFilterStrategy. Processing methods for step-types introduced. This is not only cleaner, but will allow users/providers to turn on/off InlineFiltering for different step types.


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/9ef8a9a6
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/9ef8a9a6
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/9ef8a9a6

Branch: refs/heads/master
Commit: 9ef8a9a6ce7fded4a98480de792d62ab0e62abab
Parents: 8eb0fdd
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Thu Sep 29 13:36:20 2016 -0600
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Mon Oct 3 08:24:17 2016 -0600

----------------------------------------------------------------------
 .../optimization/InlineFilterStrategy.java      | 240 ++++++++++---------
 1 file changed, 125 insertions(+), 115 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/9ef8a9a6/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
index 0b7a5cc..a3ed9a1 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
@@ -75,137 +75,147 @@ public final class InlineFilterStrategy extends AbstractTraversalStrategy<Traver
         boolean changed = true; // recursively walk child traversals trying to inline them into the current traversal line.
         while (changed) {
             changed = false;
-            // filter(x.y) --> x.y
-            for (final TraversalFilterStep<?> step : TraversalHelper.getStepsOfClass(TraversalFilterStep.class, traversal)) {
-                final Traversal.Admin<?, ?> childTraversal = step.getLocalChildren().get(0);
-                if (TraversalHelper.hasAllStepsOfClass(childTraversal, FilterStep.class) &&
-                        !TraversalHelper.hasStepOfClass(childTraversal,
-                                DropStep.class,
-                                RangeGlobalStep.class,
-                                DedupGlobalStep.class,
-                                LambdaHolder.class)) {
+            for (final FilterStep<?> step : TraversalHelper.getStepsOfAssignableClass(FilterStep.class, traversal)) {
+                if (step instanceof TraversalFilterStep && InlineFilterStrategy.processTraversalFilterStep((TraversalFilterStep) step, traversal))
+                    // filter(x.y) --> x.y
                     changed = true;
-                    TraversalHelper.applySingleLevelStrategies(traversal, childTraversal, InlineFilterStrategy.class);
-                    final Step<?, ?> finalStep = childTraversal.getEndStep();
-                    TraversalHelper.insertTraversal((Step) step, childTraversal, traversal);
-                    TraversalHelper.copyLabels(step, finalStep, false);
-                    traversal.removeStep(step);
+                else if (step instanceof OrStep && InlineFilterStrategy.processOrStep((OrStep) step, traversal))
+                    // or(has(x,y),has(x,z)) --> has(x,y.or(z))
+                    changed = true;
+                else if (step instanceof AndStep && InlineFilterStrategy.processAndStep((AndStep) step, traversal))
+                    // and(x,y) --> x.y
+                    changed = true;
+            }
+            // match(as('a').has(key,value),...) --> as('a').has(key,value).match(...)
+            if (traversal.getParent() instanceof EmptyStep) {
+                for (final MatchStep<?, ?> step : TraversalHelper.getStepsOfClass(MatchStep.class, traversal)) {
+                    if (InlineFilterStrategy.processMatchStep(step, traversal))
+                        changed = true;
                 }
             }
-            // or(has(x,y),has(x,z)) --> has(x,y.or(z))
-            for (final OrStep<?> step : TraversalHelper.getStepsOfClass(OrStep.class, traversal)) {
-                boolean process = true;
-                String key = null;
-                P predicate = null;
-                final List<String> labels = new ArrayList<>();
-                for (final Traversal.Admin<?, ?> childTraversal : step.getLocalChildren()) {
-                    this.apply(childTraversal); // todo: this may be a bad idea, but I can't seem to find a test case to break it
-                    for (final Step<?, ?> childStep : childTraversal.getSteps()) {
-                        if (childStep instanceof HasStep) {
-                            for (final HasContainer hasContainer : ((HasStep<?>) childStep).getHasContainers()) {
-                                if (null == key)
-                                    key = hasContainer.getKey();
-                                else if (!hasContainer.getKey().equals(key)) {
-                                    process = false;
-                                    break;
-                                }
-                                predicate = null == predicate ?
-                                        hasContainer.getPredicate() :
-                                        predicate.or(hasContainer.getPredicate());
-                            }
-                            labels.addAll(childStep.getLabels());
-                        } else {
+        }
+    }
+
+    ////////////////////////////
+    ///////////////////////////
+
+    private static final boolean processTraversalFilterStep(final TraversalFilterStep<?> step, final Traversal.Admin<?, ?> traversal) {
+        final Traversal.Admin<?, ?> childTraversal = step.getLocalChildren().get(0);
+        if (TraversalHelper.hasAllStepsOfClass(childTraversal, FilterStep.class) &&
+                !TraversalHelper.hasStepOfClass(childTraversal,
+                        DropStep.class,
+                        RangeGlobalStep.class,
+                        DedupGlobalStep.class,
+                        LambdaHolder.class)) {
+            TraversalHelper.applySingleLevelStrategies(traversal, childTraversal, InlineFilterStrategy.class);
+            final Step<?, ?> finalStep = childTraversal.getEndStep();
+            TraversalHelper.insertTraversal((Step) step, childTraversal, traversal);
+            TraversalHelper.copyLabels(step, finalStep, false);
+            traversal.removeStep(step);
+            return true;
+        }
+        return false;
+    }
+
+    private static final boolean processOrStep(final OrStep<?> step, final Traversal.Admin<?, ?> traversal) {
+        boolean process = true;
+        String key = null;
+        P predicate = null;
+        final List<String> labels = new ArrayList<>();
+        for (final Traversal.Admin<?, ?> childTraversal : step.getLocalChildren()) {
+            InlineFilterStrategy.instance().apply(childTraversal); // todo: this may be a bad idea, but I can't seem to find a test case to break it
+            for (final Step<?, ?> childStep : childTraversal.getSteps()) {
+                if (childStep instanceof HasStep) {
+                    for (final HasContainer hasContainer : ((HasStep<?>) childStep).getHasContainers()) {
+                        if (null == key)
+                            key = hasContainer.getKey();
+                        else if (!hasContainer.getKey().equals(key)) {
                             process = false;
                             break;
                         }
+                        predicate = null == predicate ?
+                                hasContainer.getPredicate() :
+                                predicate.or(hasContainer.getPredicate());
                     }
-                    if (!process)
-                        break;
-                }
-                if (process) {
-                    changed = true;
-                    final HasStep hasStep = new HasStep<>(traversal, new HasContainer(key, predicate));
-                    TraversalHelper.replaceStep(step, hasStep, traversal);
-                    TraversalHelper.copyLabels(step, hasStep, false);
-                    for (final String label : labels) {
-                        hasStep.addLabel(label);
-                    }
+                    labels.addAll(childStep.getLabels());
+                } else {
+                    process = false;
+                    break;
                 }
             }
-            // and(x,y) --> x.y
-            for (final AndStep<?> step : TraversalHelper.getStepsOfClass(AndStep.class, traversal)) {
-                boolean process = true;
-                for (final Traversal.Admin<?, ?> childTraversal : step.getLocalChildren()) {
-                    if (!TraversalHelper.hasAllStepsOfClass(childTraversal, FilterStep.class) ||
-                            TraversalHelper.hasStepOfClass(childTraversal,
-                                    DropStep.class,
-                                    RangeGlobalStep.class,
-                                    DedupGlobalStep.class,
-                                    LambdaHolder.class)) {
-                        process = false;
-                        break;
-                    }
-                }
-                if (process) {
-                    changed = true;
-                    final List<Traversal.Admin<?, ?>> childTraversals = (List) step.getLocalChildren();
-                    Step<?, ?> finalStep = null;
-                    for (int i = childTraversals.size() - 1; i >= 0; i--) {
-                        final Traversal.Admin<?, ?> childTraversal = childTraversals.get(i);
-                        TraversalHelper.applySingleLevelStrategies(traversal, childTraversal, InlineFilterStrategy.class);
-                        if (null == finalStep)
-                            finalStep = childTraversal.getEndStep();
-                        TraversalHelper.insertTraversal((Step) step, childTraversals.get(i), traversal);
+            if (!process)
+                break;
+        }
+        if (process) {
+            final HasStep hasStep = new HasStep<>(traversal, new HasContainer(key, predicate));
+            TraversalHelper.replaceStep(step, hasStep, traversal);
+            TraversalHelper.copyLabels(step, hasStep, false);
+            for (final String label : labels) {
+                hasStep.addLabel(label);
+            }
+            return true;
+        }
+        return false;
+    }
 
-                    }
-                    if (null != finalStep) TraversalHelper.copyLabels(step, finalStep, false);
-                    traversal.removeStep(step);
-                }
+    private static final boolean processAndStep(final AndStep<?> step, final Traversal.Admin<?, ?> traversal) {
+        boolean process = true;
+        for (final Traversal.Admin<?, ?> childTraversal : step.getLocalChildren()) {
+            if (!TraversalHelper.hasAllStepsOfClass(childTraversal, FilterStep.class) ||
+                    TraversalHelper.hasStepOfClass(childTraversal,
+                            DropStep.class,
+                            RangeGlobalStep.class,
+                            DedupGlobalStep.class,
+                            LambdaHolder.class)) {
+                process = false;
+                break;
             }
-            // match(as('a').has(key,value),...) --> as('a').has(key,value).match(...)
-            if (traversal.getParent() instanceof EmptyStep) {
-                for (final MatchStep<?, ?> step : TraversalHelper.getStepsOfClass(MatchStep.class, traversal)) {
-                    final String startLabel = determineStartLabelForHasPullOut(step);
-                    if (null != startLabel) {
-                        for (final Traversal.Admin<?, ?> matchTraversal : new ArrayList<>(step.getGlobalChildren())) {
-                            if (!(step.getPreviousStep() instanceof EmptyStep) &&
-                                    TraversalHelper.hasAllStepsOfClass(matchTraversal,
-                                            HasStep.class,
-                                            MatchStep.MatchStartStep.class,
-                                            MatchStep.MatchEndStep.class) &&
-                                    matchTraversal.getStartStep() instanceof MatchStep.MatchStartStep &&
-                                    startLabel.equals(((MatchStep.MatchStartStep) matchTraversal.getStartStep()).getSelectKey().orElse(null))) {
-                                changed = true;
-                                final String endLabel = ((MatchStep.MatchEndStep) matchTraversal.getEndStep()).getMatchKey().orElse(null); // why would this exist? but just in case
-                                matchTraversal.removeStep(0);                                       // remove MatchStartStep
-                                matchTraversal.removeStep(matchTraversal.getSteps().size() - 1);    // remove MatchEndStep
-                                TraversalHelper.applySingleLevelStrategies(traversal, matchTraversal, InlineFilterStrategy.class);
-                                step.removeGlobalChild(matchTraversal);
-                                step.getPreviousStep().addLabel(startLabel);
-                                // TODO: matchTraversal.getEndStep().addLabel(startLabel); (perhaps insert an identity so filter rank can push has()-left)
-                                if (null != endLabel) matchTraversal.getEndStep().addLabel(endLabel);
-                                TraversalHelper.insertTraversal((Step) step.getPreviousStep(), matchTraversal, traversal);
-                            }
-                        }
-                        if (step.getGlobalChildren().isEmpty())
-                            traversal.removeStep(step);
-                    }
-                }
+        }
+        if (process) {
+            final List<Traversal.Admin<?, ?>> childTraversals = (List) step.getLocalChildren();
+            Step<?, ?> finalStep = null;
+            for (int i = childTraversals.size() - 1; i >= 0; i--) {
+                final Traversal.Admin<?, ?> childTraversal = childTraversals.get(i);
+                TraversalHelper.applySingleLevelStrategies(traversal, childTraversal, InlineFilterStrategy.class);
+                if (null == finalStep)
+                    finalStep = childTraversal.getEndStep();
+                TraversalHelper.insertTraversal((Step) step, childTraversals.get(i), traversal);
+
             }
+            if (null != finalStep) TraversalHelper.copyLabels(step, finalStep, false);
+            traversal.removeStep(step);
+            return true;
         }
+        return false;
     }
 
-    private static final String determineStartLabelForHasPullOut(final MatchStep<?, ?> matchStep) {
-        final String startLabel = MatchStep.Helper.computeStartLabel(matchStep.getGlobalChildren());
-        Step<?, ?> previousStep = matchStep.getPreviousStep();
-        if (previousStep.getLabels().contains(startLabel))
-            return startLabel;
-        while (!(previousStep instanceof EmptyStep)) {
-            if (!previousStep.getLabels().isEmpty())
-                return null;
-            previousStep = previousStep.getPreviousStep();
+    private static final boolean processMatchStep(final MatchStep<?, ?> step, final Traversal.Admin<?, ?> traversal) {
+        if (step.getPreviousStep() instanceof EmptyStep)
+            return false;
+        boolean changed = false;
+        final String startLabel = MatchStep.Helper.computeStartLabel(step.getGlobalChildren());
+        for (final Traversal.Admin<?, ?> matchTraversal : new ArrayList<>(step.getGlobalChildren())) {
+            if (TraversalHelper.hasAllStepsOfClass(matchTraversal,
+                    HasStep.class,
+                    MatchStep.MatchStartStep.class,
+                    MatchStep.MatchEndStep.class) &&
+                    matchTraversal.getStartStep() instanceof MatchStep.MatchStartStep &&
+                    startLabel.equals(((MatchStep.MatchStartStep) matchTraversal.getStartStep()).getSelectKey().orElse(null))) {
+                changed = true;
+                final String endLabel = ((MatchStep.MatchEndStep) matchTraversal.getEndStep()).getMatchKey().orElse(null); // why would this exist? but just in case
+                matchTraversal.removeStep(0);                                       // remove MatchStartStep
+                matchTraversal.removeStep(matchTraversal.getSteps().size() - 1);    // remove MatchEndStep
+                TraversalHelper.applySingleLevelStrategies(traversal, matchTraversal, InlineFilterStrategy.class);
+                step.removeGlobalChild(matchTraversal);
+                step.getPreviousStep().addLabel(startLabel);
+                // TODO: matchTraversal.getEndStep().addLabel(startLabel); (perhaps insert an identity so filter rank can push has()-left)
+                if (null != endLabel) matchTraversal.getEndStep().addLabel(endLabel);
+                TraversalHelper.insertTraversal((Step) step.getPreviousStep(), matchTraversal, traversal);
+            }
         }
-        return startLabel;
+        if (step.getGlobalChildren().isEmpty())
+            traversal.removeStep(step);
+        return changed;
     }
 
     @Override


[5/9] tinkerpop git commit: added more FilterRankStrategy tests.

Posted by ok...@apache.org.
added more FilterRankStrategy tests.


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/68bbae10
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/68bbae10
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/68bbae10

Branch: refs/heads/master
Commit: 68bbae10521350085b60f4dbf8819f06494ff6be
Parents: ff1c384
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Thu Sep 29 15:56:06 2016 -0600
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Mon Oct 3 08:24:17 2016 -0600

----------------------------------------------------------------------
 .../traversal/strategy/optimization/FilterRankingStrategy.java | 2 +-
 .../strategy/optimization/FilterRankingStrategyTest.java       | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/68bbae10/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
index dead668..06726b1 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategy.java
@@ -92,7 +92,7 @@ public final class FilterRankingStrategy extends AbstractTraversalStrategy<Trave
         while(modified) {
             modified = false;
             for (final Step<?, ?> step : traversal.getSteps()) {
-                if (!step.getLabels().isEmpty()) {
+                if (step instanceof FilterStep && !step.getLabels().isEmpty()) {
                     final Step<?, ?> nextStep = step.getNextStep();
                     if (nextStep instanceof FilterStep && !(nextStep instanceof TraversalParent)) {
                         TraversalHelper.copyLabels(step, nextStep, true);

http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/68bbae10/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
index 52379fd..bd12e34 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/FilterRankingStrategyTest.java
@@ -32,7 +32,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 
-import static org.apache.tinkerpop.gremlin.process.traversal.P.eq;
+import static org.apache.tinkerpop.gremlin.process.traversal.P.neq;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.filter;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
 import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.in;
@@ -80,8 +80,10 @@ public class FilterRankingStrategyTest {
 
         return Arrays.asList(new Object[][]{
                 {__.dedup().order(), __.dedup().order(), Collections.emptyList()},
+                {__.has("name", "marko").as("a").out().as("b").has("age", 32).where("a", neq("b")), __.has("name", "marko").as("a").out().as("b").has("age", 32).where("a", neq("b")), Collections.emptyList()},
+                {__.has("name", "marko").as("a").out().has("age", 32).as("b").where("a", neq("b")), __.has("name", "marko").as("a").out().has("age", 32).as("b").where("a", neq("b")), Collections.emptyList()},
                 {__.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a"), __.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a"), Collections.emptyList()},
-                {__.has("name", "marko").dedup().as("a").has("age", 32).has("name", "bob").as("b"), __.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a","b"), Collections.emptyList()},
+                {__.has("name", "marko").dedup().as("a").has("age", 32).has("name", "bob").as("b"), __.has("name", "marko").has("age", 32).dedup().has("name", "bob").as("a", "b"), Collections.emptyList()},
                 {__.order().dedup(), __.dedup().order(), Collections.emptyList()},
                 {__.order().as("a").dedup(), __.order().as("a").dedup(), Collections.emptyList()},
                 {__.identity().order().dedup(), __.dedup().order(), Collections.singletonList(IdentityRemovalStrategy.instance())},


[8/9] tinkerpop git commit: minor change to CHANGELOG.

Posted by ok...@apache.org.
minor change to CHANGELOG.


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/62197e25
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/62197e25
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/62197e25

Branch: refs/heads/master
Commit: 62197e25369bfcfd9b7036c6cc379182e5a6b073
Parents: e3991ea
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Mon Oct 3 08:14:58 2016 -0600
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Mon Oct 3 08:24:17 2016 -0600

----------------------------------------------------------------------
 CHANGELOG.asciidoc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/62197e25/CHANGELOG.asciidoc
----------------------------------------------------------------------
diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index 638a80c..60e895b 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -26,7 +26,7 @@ image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
 TinkerPop 3.2.3 (Release Date: NOT OFFICIALLY RELEASED YET)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-* `FilterRankStrategy` now propagates labels "right" across non-`TraversalParent` filters.
+* `FilterRankStrategy` now propagates labels "right" non-`Scoping` filters.
 * Fixed a bug in `ConnectiveP` where nested equivalent connectives should be inlined.
 * Fixed a bug in `IncidentToAdjacentStrategy` where `TreeStep` traversals were allowed.
 * Fixed a end-step label bug in `MatchPredicateStrategy`.


[2/9] tinkerpop git commit: made the recommended changes from @dkuppitz.

Posted by ok...@apache.org.
made the recommended changes from @dkuppitz.


Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/e3991eae
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/e3991eae
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/e3991eae

Branch: refs/heads/master
Commit: e3991eae76e1a3eca64c9b20582c025a92447daf
Parents: b8a92a3
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Mon Oct 3 08:09:19 2016 -0600
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Mon Oct 3 08:24:17 2016 -0600

----------------------------------------------------------------------
 .../optimization/InlineFilterStrategy.java      | 29 ++++++++------------
 1 file changed, 12 insertions(+), 17 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/e3991eae/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
index 820143a..8072ca0 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/optimization/InlineFilterStrategy.java
@@ -42,6 +42,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
@@ -75,24 +76,18 @@ public final class InlineFilterStrategy extends AbstractTraversalStrategy<Traver
         boolean changed = true; // recursively walk child traversals trying to inline them into the current traversal line.
         while (changed) {
             changed = false;
-            for (final FilterStep<?> step : TraversalHelper.getStepsOfAssignableClass(FilterStep.class, traversal)) {
-                if (step instanceof HasStep && InlineFilterStrategy.processHasStep((HasStep) step, traversal))
-                    // has(a,b).has(c) --> has(a,b,c)
-                    changed = true;
-                else if (step instanceof TraversalFilterStep && InlineFilterStrategy.processTraversalFilterStep((TraversalFilterStep) step, traversal))
-                    // filter(x.y) --> x.y
-                    changed = true;
-                else if (step instanceof OrStep && InlineFilterStrategy.processOrStep((OrStep) step, traversal))
-                    // or(has(x,y),has(x,z)) --> has(x,y.or(z))
-                    changed = true;
-                else if (step instanceof AndStep && InlineFilterStrategy.processAndStep((AndStep) step, traversal))
-                    // and(x,y) --> x.y
-                    changed = true;
+            final Iterator<FilterStep> filterStepIterator = TraversalHelper.getStepsOfAssignableClass(FilterStep.class, traversal).iterator();
+            while (!changed && filterStepIterator.hasNext()) {
+                final FilterStep<?> step = filterStepIterator.next();
+                changed = step instanceof HasStep && InlineFilterStrategy.processHasStep((HasStep) step, traversal) ||
+                        step instanceof TraversalFilterStep && InlineFilterStrategy.processTraversalFilterStep((TraversalFilterStep) step, traversal) ||
+                        step instanceof OrStep && InlineFilterStrategy.processOrStep((OrStep) step, traversal) ||
+                        step instanceof AndStep && InlineFilterStrategy.processAndStep((AndStep) step, traversal);
             }
-            // match(as('a').has(key,value),...) --> as('a').has(key,value).match(...)
-            if (traversal.getParent() instanceof EmptyStep) {
-                for (final MatchStep<?, ?> step : TraversalHelper.getStepsOfClass(MatchStep.class, traversal)) {
-                    if (InlineFilterStrategy.processMatchStep(step, traversal))
+            if (!changed && traversal.getParent() instanceof EmptyStep) {
+                final Iterator<MatchStep> matchStepIterator = TraversalHelper.getStepsOfClass(MatchStep.class, traversal).iterator();
+                while (!changed && matchStepIterator.hasNext()) {
+                    if (InlineFilterStrategy.processMatchStep(matchStepIterator.next(), traversal))
                         changed = true;
                 }
             }