tinkerpop-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From spmalle...@apache.org
Subject svn commit: r1763293 [2/36] - in /tinkerpop/site: docs/3.2.3-SNAPSHOT/ docs/3.2.3-SNAPSHOT/dev/developer/ docs/3.2.3-SNAPSHOT/dev/provider/ docs/3.2.3-SNAPSHOT/images/ docs/3.2.3-SNAPSHOT/recipes/ docs/3.2.3-SNAPSHOT/reference/ docs/3.2.3-SNAPSHOT/upgr...
Date Tue, 04 Oct 2016 15:59:32 GMT
Modified: tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html
URL: http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html?rev=1763293&r1=1763292&r2=1763293&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html (original)
+++ tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html Tue Oct  4 15:59:29 2016
@@ -1997,10 +1997,10 @@ system providers for two purposes:</p>
 gremlin&gt; graph.features()
 ==&gt;FEATURES
 &gt; GraphFeatures
-&gt;-- <span class="key">Transactions</span>: <span class="predefined-constant">false</span>
 &gt;-- <span class="key">Persistence</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">ConcurrentAccess</span>: <span class="predefined-constant">false</span>
 &gt;-- <span class="key">ThreadedTransactions</span>: <span class="predefined-constant">false</span>
+&gt;-- <span class="key">Transactions</span>: <span class="predefined-constant">false</span>
 &gt;-- <span class="key">Computer</span>: <span class="predefined-constant">true</span>
 &gt; VariableFeatures
 &gt;-- <span class="key">Variables</span>: <span class="predefined-constant">true</span>
@@ -2023,11 +2023,10 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">LongArrayValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">StringArrayValues</span>: <span class="predefined-constant">true</span>
 &gt; VertexFeatures
-&gt;-- <span class="key">MetaProperties</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">AddVertices</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">RemoveVertices</span>: <span class="predefined-constant">true</span>
+&gt;-- <span class="key">MetaProperties</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">MultiProperties</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">AddProperty</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">RemoveProperty</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">NumericIds</span>: <span class="predefined-constant">true</span>
@@ -2035,8 +2034,8 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">UuidIds</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">CustomIds</span>: <span class="predefined-constant">false</span>
 &gt;-- <span class="key">AnyIds</span>: <span class="predefined-constant">true</span>
-&gt; VertexPropertyFeatures
 &gt;-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
+&gt; VertexPropertyFeatures
 &gt;-- <span class="key">AddProperty</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">RemoveProperty</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">NumericIds</span>: <span class="predefined-constant">true</span>
@@ -2044,6 +2043,7 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">UuidIds</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">CustomIds</span>: <span class="predefined-constant">false</span>
 &gt;-- <span class="key">AnyIds</span>: <span class="predefined-constant">true</span>
+&gt;-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="predefined-type">Properties</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">BooleanValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">ByteValues</span>: <span class="predefined-constant">true</span>
@@ -2066,7 +2066,6 @@ gremlin&gt; graph.features()
 &gt; EdgeFeatures
 &gt;-- <span class="key">AddEdges</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">RemoveEdges</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">AddProperty</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">RemoveProperty</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">NumericIds</span>: <span class="predefined-constant">true</span>
@@ -2074,6 +2073,7 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">UuidIds</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">CustomIds</span>: <span class="predefined-constant">false</span>
 &gt;-- <span class="key">AnyIds</span>: <span class="predefined-constant">true</span>
+&gt;-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
 &gt; EdgePropertyFeatures
 &gt;-- <span class="predefined-type">Properties</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">BooleanValues</span>: <span class="predefined-constant">true</span>
@@ -2934,7 +2934,7 @@ gremlin&gt; g = graph.traversal()
 gremlin&gt; f = <span class="keyword">new</span> <span class="predefined-type">ByteArrayOutputStream</span>()
 ==&gt;
 gremlin&gt; mapper = graph.io(graphson()).mapper().embedTypes(<span class="predefined-constant">true</span>).create()
-==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">557</span>c837
+==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">406</span>c330c
 gremlin&gt; graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span class="integer">1</span>).next(), BOTH)
 gremlin&gt; f.close()</code></pre>
 </div>
@@ -3124,7 +3124,7 @@ gremlin&gt; g = graph.traversal()
 gremlin&gt; f = <span class="keyword">new</span> <span class="predefined-type">ByteArrayOutputStream</span>()
 ==&gt;
 gremlin&gt; mapper = graph.io(graphson()).mapper().version(GraphSONVersion.V2_0).create()
-==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">63</span>b5a020
+==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="float">31d</span><span class="integer">3</span>acbf
 gremlin&gt; graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span class="integer">1</span>).next(), BOTH)
 gremlin&gt; f.close()</code></pre>
 </div>
@@ -4046,13 +4046,13 @@ gremlin&gt; graph.io(graphml()).readGrap
 gremlin&gt; g = graph.traversal()
 ==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">808</span> <span class="key">edges</span>:<span class="integer">8049</span>], standard]
 gremlin&gt; clockWithResult(<span class="integer">1</span>){g.V().both().both().both().count().next()} <span class="comment">//</span><b>(1)</b>
-==&gt;<span class="float">8669.263931</span>
+==&gt;<span class="float">8477.852246</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; clockWithResult(<span class="integer">1</span>){g.V().repeat(both()).times(<span class="integer">3</span>).count().next()} <span class="comment">//</span><b>(2)</b>
-==&gt;<span class="float">14.115905</span>
+==&gt;<span class="float">24.310301</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; clockWithResult(<span class="integer">1</span>){g.V().both().barrier().both().barrier().both().barrier().count().next()} <span class="comment">//</span><b>(3)</b>
-==&gt;<span class="float">14.185149</span>
+==&gt;<span class="float">13.720417999999999</span>
 ==&gt;<span class="integer">126653966</span></code></pre>
 </div>
 </div>
@@ -4086,7 +4086,7 @@ gremlin&gt; graph.io(graphml()).readGrap
 gremlin&gt; g = graph.traversal().withStrategies(LazyBarrierStrategy.instance())
 ==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">808</span> <span class="key">edges</span>:<span class="integer">8049</span>], standard]
 gremlin&gt; clockWithResult(<span class="integer">1</span>){g.V().both().both().both().count().next()}
-==&gt;<span class="float">11.988038</span>
+==&gt;<span class="float">17.143065999999997</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; g.V().both().both().both().count().iterate().toString() <span class="comment">//</span><b>(1)</b>
 ==&gt;[TinkerGraphStep(vertex,<span class="type">[]</span>), VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">10000</span>), VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">10000</span>), VertexStep(BOTH,edge), CountGlobalStep]</code></pre>
@@ -4307,9 +4307,8 @@ gremlin&gt; g.V().hasLabel(<span class="
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().coin(<span class="float">0.5</span>)
-==&gt;v[<span class="integer">1</span>]
-==&gt;v[<span class="integer">2</span>]
-==&gt;v[<span class="integer">5</span>]
+==&gt;v[<span class="integer">4</span>]
+==&gt;v[<span class="integer">6</span>]
 gremlin&gt; g.V().coin(<span class="float">0.0</span>)
 gremlin&gt; g.V().coin(<span class="float">1.0</span>)
 ==&gt;v[<span class="integer">1</span>]
@@ -4428,12 +4427,12 @@ has been seen or not.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().valueMap(<span class="predefined-constant">true</span>, <span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
-==&gt;[<span class="key">name</span>:[marko],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">1</span>]
-==&gt;[<span class="key">name</span>:[vadas],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">2</span>]
-==&gt;[<span class="key">name</span>:[lop],<span class="key">label</span>:software,<span class="key">id</span>:<span class="integer">3</span>]
-==&gt;[<span class="key">name</span>:[josh],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">4</span>]
-==&gt;[<span class="key">name</span>:[ripple],<span class="key">label</span>:software,<span class="key">id</span>:<span class="integer">5</span>]
-==&gt;[<span class="key">name</span>:[peter],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">6</span>]
+==&gt;[<span class="key">id</span>:<span class="integer">1</span>,<span class="key">name</span>:[marko],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">2</span>,<span class="key">name</span>:[vadas],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">3</span>,<span class="key">name</span>:[lop],<span class="key">label</span>:software]
+==&gt;[<span class="key">id</span>:<span class="integer">4</span>,<span class="key">name</span>:[josh],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">5</span>,<span class="key">name</span>:[ripple],<span class="key">label</span>:software]
+==&gt;[<span class="key">id</span>:<span class="integer">6</span>,<span class="key">name</span>:[peter],<span class="key">label</span>:person]
 gremlin&gt; g.V().dedup().by(label).values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
 ==&gt;marko
 ==&gt;lop</code></pre>
@@ -4508,23 +4507,23 @@ post strategy application. The final tra
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).outE().identity().inV().count().is(gt(<span class="integer">5</span>)).explain()
 ==&gt;Traversal Explanation
-===============================================================================================================================================================================
+=====================================================================================================================================================================================================
 Original Traversal                 [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
 
 ConnectiveStrategy           [D]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-IdentityRemovalStrategy      [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-MatchPredicateStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,vertex), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-FilterRankingStrategy        [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-RangeByIsCountStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-PathRetractionStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-TinkerGraphStepStrategy      [P]   [TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-ProfileStrategy              [F]   [TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-StandardVerificationStrategy [V]   [TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+InlineFilterStrategy         [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+MatchPredicateStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+FilterRankingStrategy        [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+PathRetractionStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+RangeByIsCountStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+TinkerGraphStepStrategy      [P]   [TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+ProfileStrategy              [F]   [TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+StandardVerificationStrategy [V]   [TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
 
-Final Traversal                    [TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]</code></pre>
+Final Traversal                    [TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -5644,15 +5643,15 @@ gremlin&gt; g.V().hasLabel(<span class="
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).order().by(shuffle)
-==&gt;v[<span class="integer">2</span>]
+==&gt;v[<span class="integer">1</span>]
 ==&gt;v[<span class="integer">6</span>]
 ==&gt;v[<span class="integer">4</span>]
-==&gt;v[<span class="integer">1</span>]
+==&gt;v[<span class="integer">2</span>]
 gremlin&gt; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).order().by(shuffle)
-==&gt;v[<span class="integer">6</span>]
-==&gt;v[<span class="integer">1</span>]
 ==&gt;v[<span class="integer">4</span>]
-==&gt;v[<span class="integer">2</span>]</code></pre>
+==&gt;v[<span class="integer">2</span>]
+==&gt;v[<span class="integer">1</span>]
+==&gt;v[<span class="integer">6</span>]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -5725,19 +5724,19 @@ The <code>pageRank()</code>-step is a <c
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g = graph.traversal().withComputer()
 ==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">6</span> <span class="key">edges</span>:<span class="integer">6</span>], graphcomputer]
 gremlin&gt; g.V().pageRank().by(<span class="string"><span class="delimiter">'</span><span class="content">pageRank</span><span class="delimiter">'</span></span>).values(<span class="string"><span class="delimiter">'</span><span class="content">pageRank</span><span class="delimiter">'</span></span>)
-==&gt;<span class="float">0.4018125</span>
+==&gt;<span class="float">0.15000000000000002</span>
+==&gt;<span class="float">0.15000000000000002</span>
 ==&gt;<span class="float">0.19250000000000003</span>
 ==&gt;<span class="float">0.19250000000000003</span>
 ==&gt;<span class="float">0.23181250000000003</span>
-==&gt;<span class="float">0.15000000000000002</span>
-==&gt;<span class="float">0.15000000000000002</span>
+==&gt;<span class="float">0.4018125</span>
 gremlin&gt; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).
            pageRank().
              by(outE(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>)).
              by(<span class="string"><span class="delimiter">'</span><span class="content">friendRank</span><span class="delimiter">'</span></span>).
            order().by(<span class="string"><span class="delimiter">'</span><span class="content">friendRank</span><span class="delimiter">'</span></span>,decr).valueMap(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">friendRank</span><span class="delimiter">'</span></span>)
-==&gt;[<span class="key">friendRank</span>:[<span class="float">0.21375000000000002</span>],<span class="key">name</span>:[josh]]
 ==&gt;[<span class="key">friendRank</span>:[<span class="float">0.21375000000000002</span>],<span class="key">name</span>:[vadas]]
+==&gt;[<span class="key">friendRank</span>:[<span class="float">0.21375000000000002</span>],<span class="key">name</span>:[josh]]
 ==&gt;[<span class="key">friendRank</span>:[<span class="float">0.15000000000000002</span>],<span class="key">name</span>:[marko]]
 ==&gt;[<span class="key">friendRank</span>:[<span class="float">0.15000000000000002</span>],<span class="key">name</span>:[peter]]</code></pre>
 </div>
@@ -5755,45 +5754,45 @@ gremlin&gt; g.V().hasLabel(<span class="
              by(<span class="string"><span class="delimiter">'</span><span class="content">friendRank</span><span class="delimiter">'</span></span>).
            order().by(<span class="string"><span class="delimiter">'</span><span class="content">friendRank</span><span class="delimiter">'</span></span>,decr).valueMap(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">friendRank</span><span class="delimiter">'</span></span>).explain()
 ==&gt;Traversal Explanation
-=============================================================================================================================================================================================================================================
-Original Traversal                 [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), OrderGlobalStep([[value(friendRank), decr]]), PropertyMapS
-                                      tep([name, friendRank],value)]
-
-VertexProgramStrategy        [D]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-ConnectiveStrategy           [D]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-IdentityRemovalStrategy      [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-IncidentToAdjacentStrategy   [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-AdjacentToIncidentStrategy   [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-MatchPredicateStrategy       [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-RepeatUnrollStrategy         [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-FilterRankingStrategy        [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-RangeByIsCountStrategy       [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-PathProcessorStrategy        [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-PathRetractionStrategy       [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-OrderLimitStrategy           [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-TinkerGraphStepStrategy      [P]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-ProfileStrategy              [F]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-ComputerVerificationStrategy [V]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-StandardVerificationStrategy [V]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+=======================================================================================================================================================================================================================================
+Original Traversal                 [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), OrderGlobalStep([[value(friendRank), decr]]), Proper
+                                      tyMapStep([name, friendRank],value)]
+
+ConnectiveStrategy           [D]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), OrderGlobalStep([[value(friendRank), decr]]), Proper
+                                      tyMapStep([name, friendRank],value)]
+VertexProgramStrategy        [D]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+IncidentToAdjacentStrategy   [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+AdjacentToIncidentStrategy   [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+InlineFilterStrategy         [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+MatchPredicateStrategy       [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+FilterRankingStrategy        [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+RepeatUnrollStrategy         [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+PathProcessorStrategy        [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+PathRetractionStrategy       [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+RangeByIsCountStrategy       [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+OrderLimitStrategy           [O]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+TinkerGraphStepStrategy      [P]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+ProfileStrategy              [F]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+ComputerVerificationStrategy [V]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
+StandardVerificationStrategy [V]   [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
 
-Final Traversal                    [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
-                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]</code></pre>
+Final Traversal                    [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), Trav
+                                      ersalVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]</code></pre>
 </div>
 </div>
 </div>
@@ -5974,18 +5973,18 @@ profile results, but durations are not e
 ==&gt;Traversal Metrics
 Step                                                               Count  Traversers       <span class="predefined-type">Time</span> (ms)    % Dur
 =============================================================================================================
-TinkerGraphStep(vertex,<span class="type">[]</span>)                                             <span class="integer">6</span>           <span class="integer">6</span>           <span class="float">0.073</span>    <span class="float">11.80</span>
-VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>           <span class="float">0.102</span>    <span class="float">16.37</span>
-VertexStep(BOTH,vertex)                                               <span class="integer">10</span>          <span class="integer">10</span>           <span class="float">0.063</span>    <span class="float">10.11</span>
-NoOpBarrierStep(<span class="integer">5000</span>)                                                 <span class="integer">10</span>           <span class="integer">3</span>           <span class="float">0.068</span>    <span class="float">11.02</span>
-VertexStep(BOTH,vertex)                                               <span class="integer">24</span>           <span class="integer">7</span>           <span class="float">0.028</span>     <span class="float">4.50</span>
-NoOpBarrierStep(<span class="integer">5000</span>)                                                 <span class="integer">24</span>           <span class="integer">5</span>           <span class="float">0.027</span>     <span class="float">4.47</span>
-VertexStep(BOTH,vertex)                                               <span class="integer">58</span>          <span class="integer">11</span>           <span class="float">0.035</span>     <span class="float">5.74</span>
-NoOpBarrierStep(<span class="integer">5000</span>)                                                 <span class="integer">58</span>           <span class="integer">6</span>           <span class="float">0.044</span>     <span class="float">7.17</span>
-HasStep([~label.eq(person)])                                          <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.033</span>     <span class="float">5.31</span>
-PropertiesStep([age],value)                                           <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.056</span>     <span class="float">9.13</span>
-SumGlobalStep                                                          <span class="integer">1</span>           <span class="integer">1</span>           <span class="float">0.089</span>    <span class="float">14.37</span>
-                                            &gt;TOTAL                     -           -           <span class="float">0.623</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                                             <span class="integer">6</span>           <span class="integer">6</span>           <span class="float">0.087</span>    <span class="float">13.14</span>
+VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>           <span class="float">0.094</span>    <span class="float">14.09</span>
+VertexStep(BOTH,vertex)                                               <span class="integer">10</span>          <span class="integer">10</span>           <span class="float">0.059</span>     <span class="float">8.89</span>
+NoOpBarrierStep(<span class="integer">5000</span>)                                                 <span class="integer">10</span>           <span class="integer">3</span>           <span class="float">0.088</span>    <span class="float">13.20</span>
+VertexStep(BOTH,vertex)                                               <span class="integer">24</span>           <span class="integer">7</span>           <span class="float">0.042</span>     <span class="float">6.42</span>
+NoOpBarrierStep(<span class="integer">5000</span>)                                                 <span class="integer">24</span>           <span class="integer">5</span>           <span class="float">0.033</span>     <span class="float">5.04</span>
+VertexStep(BOTH,vertex)                                               <span class="integer">58</span>          <span class="integer">11</span>           <span class="float">0.035</span>     <span class="float">5.26</span>
+NoOpBarrierStep(<span class="integer">5000</span>)                                                 <span class="integer">58</span>           <span class="integer">6</span>           <span class="float">0.048</span>     <span class="float">7.27</span>
+HasStep([~label.eq(person)])                                          <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.038</span>     <span class="float">5.78</span>
+PropertiesStep([age],value)                                           <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.046</span>     <span class="float">6.96</span>
+SumGlobalStep                                                          <span class="integer">1</span>           <span class="integer">1</span>           <span class="float">0.093</span>    <span class="float">13.95</span>
+                                            &gt;TOTAL                     -           -           <span class="float">0.668</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6033,9 +6032,9 @@ gremlin&gt; metrics = t.getSideEffects()
 ==&gt;Traversal Metrics
 Step                                                               Count  Traversers       <span class="predefined-type">Time</span> (ms)    % Dur
 =============================================================================================================
-TinkerGraphStep(vertex,<span class="type">[]</span>)                                             <span class="integer">6</span>           <span class="integer">6</span>           <span class="float">0.140</span>   -<span class="float">78.16</span>
-VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>          -<span class="float">0.319</span>   <span class="float">178.16</span>
-                                            &gt;TOTAL                     -           -          -<span class="float">0.179</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                                             <span class="integer">6</span>           <span class="integer">6</span>           <span class="float">0.105</span>  -<span class="float">102.63</span>
+VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>          -<span class="float">0.208</span>   <span class="float">202.63</span>
+                                            &gt;TOTAL                     -           -          -<span class="float">0.103</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6187,8 +6186,8 @@ gremlin&gt; g.V().hasLabel(<span class="
            program(PageRankVertexProgram.build().property(<span class="string"><span class="delimiter">'</span><span class="content">rank</span><span class="delimiter">'</span></span>).create(graph)).
              order().by(<span class="string"><span class="delimiter">'</span><span class="content">rank</span><span class="delimiter">'</span></span>, incr).
            valueMap(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">rank</span><span class="delimiter">'</span></span>)
-==&gt;[<span class="key">name</span>:[peter],<span class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
 ==&gt;[<span class="key">name</span>:[marko],<span class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
+==&gt;[<span class="key">name</span>:[peter],<span class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
 ==&gt;[<span class="key">name</span>:[vadas],<span class="key">rank</span>:[<span class="float">0.19250000000000003</span>]]
 ==&gt;[<span class="key">name</span>:[josh],<span class="key">rank</span>:[<span class="float">0.19250000000000003</span>]]</code></pre>
 </div>
@@ -6456,14 +6455,14 @@ value is accessed (<code>sack()</code>).
 ==&gt;<span class="float">1.0</span>
 ==&gt;<span class="float">1.0</span>
 gremlin&gt; rand = <span class="keyword">new</span> <span class="predefined-type">Random</span>()
-==&gt;java.util.Random<span class="error">@</span><span class="float">6567d</span>e86
+==&gt;java.util.Random<span class="annotation">@f6b128b</span>
 gremlin&gt; g.withSack {rand.nextFloat()}.V().sack()
-==&gt;<span class="float">0.6391494</span>
-==&gt;<span class="float">0.8057445</span>
-==&gt;<span class="float">0.7621683</span>
-==&gt;<span class="float">0.85526294</span>
-==&gt;<span class="float">0.10751295</span>
-==&gt;<span class="float">0.51945925</span></code></pre>
+==&gt;<span class="float">0.10865861</span>
+==&gt;<span class="float">0.68384004</span>
+==&gt;<span class="float">0.98400146</span>
+==&gt;<span class="float">0.32805628</span>
+==&gt;<span class="float">0.6485936</span>
+==&gt;<span class="float">0.9923735</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6574,7 +6573,7 @@ gremlin&gt; g.withBulk(<span class="pred
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().outE().sample(<span class="integer">1</span>).values(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>)
-==&gt;<span class="float">0.5</span>
+==&gt;<span class="float">1.0</span>
 gremlin&gt; g.V().outE().sample(<span class="integer">1</span>).by(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>).values(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>)
 ==&gt;<span class="float">1.0</span>
 gremlin&gt; g.V().outE().sample(<span class="integer">2</span>).by(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>).values(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>)
@@ -6594,15 +6593,15 @@ the traverser never splits and continues
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V(<span class="integer">1</span>).repeat(local(
                   bothE().sample(<span class="integer">1</span>).by(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>).otherV()
                 )).times(<span class="integer">5</span>)
-==&gt;v[<span class="integer">4</span>]
+==&gt;v[<span class="integer">3</span>]
 gremlin&gt; g.V(<span class="integer">1</span>).repeat(local(
                   bothE().sample(<span class="integer">1</span>).by(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>).otherV()
                 )).times(<span class="integer">5</span>).path()
-==&gt;[v[<span class="integer">1</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">4</span>],v[<span class="integer">4</span>],e[<span class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span class="integer">3</span>],v[<span class="integer">3</span>],e[<span class="integer">12</span>][<span class="integer">6</span>-created-&gt;<span class="integer">3</span>],v[<span class="integer">6</span>],e[<span class="integer">12</span>][<span class="integer">6</span>-created-&gt;<span class="integer">3</span>],v[<span class="integer">3</span>],e[<span class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span class="integer">3</span>],v[<span class="integer">4</span>]]
+==&gt;[v[<span class="integer">1</span>],e[<span class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span class="integer">3</span>],v[<span class="integer">3</span>],e[<span class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span class="integer">3</span>],v[<span class="integer">1</span>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">2</span>],v[<span class="integer">2</span>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">2</span>],v[<span class="integer">1</span>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">2</span>],v[<span class="integer">2</span>]]
 gremlin&gt; g.V(<span class="integer">1</span>).repeat(local(
                   bothE().sample(<span class="integer">1</span>).by(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>).otherV()
                 )).times(<span class="integer">10</span>).path()
-==&gt;[v[<span class="integer">1</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">4</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="integer">5</span>],v[<span class="integer">5</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="integer">5</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="integer">5</span>],v[<span class="integer">5</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="integer">5</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="integer">5</span>],v[<span class="integer">5</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="inte
 ger">5</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="integer">5</span>],v[<span class="integer">5</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="integer">5</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="integer">5</span>],v[<span class="integer">5</span>]]</code></pre>
+==&gt;[v[<span class="integer">1</span>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">2</span>],v[<span class="integer">2</span>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">2</span>],v[<span class="integer">1</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">4</span>],v[<span class="integer">4</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">4</span>],v[<span class="integer">1</span>],e[<span class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span class="integer">3</span>],v[<span class="integer">3</span>],e[<span class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span class="integer">3</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="integer">5</sp
 an>],v[<span class="integer">5</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span class="integer">5</span>],v[<span class="integer">4</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">4</span>],v[<span class="integer">1</span>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span class="integer">2</span>],v[<span class="integer">2</span>]]</code></pre>
 </div>
 </div>
 </div>
@@ -6863,8 +6862,8 @@ gremlin&gt; g.V().store(<span class="str
 </div>
 </div>
 <div class="paragraph">
-<p>It is interesting to note that there are three results in the <code>store()</code> side-effect even though the interval
-selection is for 2 objects. Realize that when the third object is on its way to the <code>range()</code> filter (i.e. <code>[0..1]</code>),
+<p>It is interesting to note that there are two results in the <code>store()</code> side-effect even though the interval
+selection is for 1 object. Realize that when the second object is on its way to the <code>range()</code> filter (i.e. <code>[0..1]</code>),
 it passes through <code>store()</code> and thus, stored before filtered.</p>
 </div>
 <div class="listingblock">
@@ -7111,7 +7110,7 @@ that can be used to time execution of a
 ==&gt;v[<span class="integer">5</span>]=<span class="integer">1136688</span>
 ==&gt;v[<span class="integer">6</span>]=<span class="integer">1136688</span>
 gremlin&gt; clock(<span class="integer">1</span>) {g.V().repeat(both().groupCount(<span class="string"><span class="delimiter">'</span><span class="content">m</span><span class="delimiter">'</span></span>)).times(<span class="integer">16</span>).cap(<span class="string"><span class="delimiter">'</span><span class="content">m</span><span class="delimiter">'</span></span>).order(local).by(values,decr).next()}
-==&gt;<span class="float">1.335103</span>
+==&gt;<span class="float">1.470978</span>
 gremlin&gt; g.V().repeat(timeLimit(<span class="integer">2</span>).both().groupCount(<span class="string"><span class="delimiter">'</span><span class="content">m</span><span class="delimiter">'</span></span>)).times(<span class="integer">16</span>).cap(<span class="string"><span class="delimiter">'</span><span class="content">m</span><span class="delimiter">'</span></span>).order(local).by(values,decr).next()
 ==&gt;v[<span class="integer">1</span>]=<span class="integer">2744208</span>
 ==&gt;v[<span class="integer">3</span>]=<span class="integer">2744208</span>
@@ -7120,7 +7119,7 @@ gremlin&gt; g.V().repeat(timeLimit(<span
 ==&gt;v[<span class="integer">5</span>]=<span class="integer">1136688</span>
 ==&gt;v[<span class="integer">6</span>]=<span class="integer">1136688</span>
 gremlin&gt; clock(<span class="integer">1</span>) {g.V().repeat(timeLimit(<span class="integer">2</span>).both().groupCount(<span class="string"><span class="delimiter">'</span><span class="content">m</span><span class="delimiter">'</span></span>)).times(<span class="integer">16</span>).cap(<span class="string"><span class="delimiter">'</span><span class="content">m</span><span class="delimiter">'</span></span>).order(local).by(values,decr).next()}
-==&gt;<span class="float">1.218626</span></code></pre>
+==&gt;<span class="float">1.235859</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -7318,30 +7317,30 @@ returned map.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).valueMap(<span class="predefined-constant">true</span>)
-==&gt;[<span class="key">name</span>:[marko],<span class="key">location</span>:[san diego,santa cruz,brussels,santa fe],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">1</span>]
-==&gt;[<span class="key">name</span>:[stephen],<span class="key">location</span>:[centreville,dulles,purcellville],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">7</span>]
-==&gt;[<span class="key">name</span>:[matthias],<span class="key">location</span>:[bremen,baltimore,oakland,seattle],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">8</span>]
-==&gt;[<span class="key">name</span>:[daniel],<span class="key">location</span>:[spremberg,kaiserslautern,aachen],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">9</span>]
+==&gt;[<span class="key">id</span>:<span class="integer">1</span>,<span class="key">name</span>:[marko],<span class="key">location</span>:[san diego,santa cruz,brussels,santa fe],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">7</span>,<span class="key">name</span>:[stephen],<span class="key">location</span>:[centreville,dulles,purcellville],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">8</span>,<span class="key">name</span>:[matthias],<span class="key">location</span>:[bremen,baltimore,oakland,seattle],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">9</span>,<span class="key">name</span>:[daniel],<span class="key">location</span>:[spremberg,kaiserslautern,aachen],<span class="key">label</span>:person]
 gremlin&gt; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).valueMap(<span class="predefined-constant">true</span>,<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
-==&gt;[<span class="key">name</span>:[marko],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">1</span>]
-==&gt;[<span class="key">name</span>:[stephen],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">7</span>]
-==&gt;[<span class="key">name</span>:[matthias],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">8</span>]
-==&gt;[<span class="key">name</span>:[daniel],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">9</span>]
+==&gt;[<span class="key">id</span>:<span class="integer">1</span>,<span class="key">name</span>:[marko],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">7</span>,<span class="key">name</span>:[stephen],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">8</span>,<span class="key">name</span>:[matthias],<span class="key">label</span>:person]
+==&gt;[<span class="key">id</span>:<span class="integer">9</span>,<span class="key">name</span>:[daniel],<span class="key">label</span>:person]
 gremlin&gt; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).properties(<span class="string"><span class="delimiter">'</span><span class="content">location</span><span class="delimiter">'</span></span>).valueMap(<span class="predefined-constant">true</span>)
-==&gt;[<span class="key">value</span>:san diego,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">1997</span>,<span class="key">endTime</span>:<span class="integer">2001</span>,<span class="key">id</span>:<span class="integer">6</span>]
-==&gt;[<span class="key">value</span>:santa cruz,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2001</span>,<span class="key">endTime</span>:<span class="integer">2004</span>,<span class="key">id</span>:<span class="integer">7</span>]
-==&gt;[<span class="key">value</span>:brussels,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2004</span>,<span class="key">endTime</span>:<span class="integer">2005</span>,<span class="key">id</span>:<span class="integer">8</span>]
-==&gt;[<span class="key">value</span>:santa fe,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2005</span>,<span class="key">id</span>:<span class="integer">9</span>]
-==&gt;[<span class="key">value</span>:centreville,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">1990</span>,<span class="key">endTime</span>:<span class="integer">2000</span>,<span class="key">id</span>:<span class="integer">10</span>]
-==&gt;[<span class="key">value</span>:dulles,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2000</span>,<span class="key">endTime</span>:<span class="integer">2006</span>,<span class="key">id</span>:<span class="integer">11</span>]
-==&gt;[<span class="key">value</span>:purcellville,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2006</span>,<span class="key">id</span>:<span class="integer">12</span>]
-==&gt;[<span class="key">value</span>:bremen,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2004</span>,<span class="key">endTime</span>:<span class="integer">2007</span>,<span class="key">id</span>:<span class="integer">13</span>]
-==&gt;[<span class="key">value</span>:baltimore,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2007</span>,<span class="key">endTime</span>:<span class="integer">2011</span>,<span class="key">id</span>:<span class="integer">14</span>]
-==&gt;[<span class="key">value</span>:oakland,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2011</span>,<span class="key">endTime</span>:<span class="integer">2014</span>,<span class="key">id</span>:<span class="integer">15</span>]
-==&gt;[<span class="key">value</span>:seattle,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2014</span>,<span class="key">id</span>:<span class="integer">16</span>]
-==&gt;[<span class="key">value</span>:spremberg,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">1982</span>,<span class="key">endTime</span>:<span class="integer">2005</span>,<span class="key">id</span>:<span class="integer">17</span>]
-==&gt;[<span class="key">value</span>:kaiserslautern,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2005</span>,<span class="key">endTime</span>:<span class="integer">2009</span>,<span class="key">id</span>:<span class="integer">18</span>]
-==&gt;[<span class="key">value</span>:aachen,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2009</span>,<span class="key">id</span>:<span class="integer">19</span>]</code></pre>
+==&gt;[<span class="key">value</span>:san diego,<span class="key">id</span>:<span class="integer">6</span>,<span class="key">startTime</span>:<span class="integer">1997</span>,<span class="key">endTime</span>:<span class="integer">2001</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:santa cruz,<span class="key">id</span>:<span class="integer">7</span>,<span class="key">startTime</span>:<span class="integer">2001</span>,<span class="key">endTime</span>:<span class="integer">2004</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:brussels,<span class="key">id</span>:<span class="integer">8</span>,<span class="key">startTime</span>:<span class="integer">2004</span>,<span class="key">endTime</span>:<span class="integer">2005</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:santa fe,<span class="key">id</span>:<span class="integer">9</span>,<span class="key">startTime</span>:<span class="integer">2005</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:centreville,<span class="key">id</span>:<span class="integer">10</span>,<span class="key">startTime</span>:<span class="integer">1990</span>,<span class="key">endTime</span>:<span class="integer">2000</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:dulles,<span class="key">id</span>:<span class="integer">11</span>,<span class="key">startTime</span>:<span class="integer">2000</span>,<span class="key">endTime</span>:<span class="integer">2006</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:purcellville,<span class="key">id</span>:<span class="integer">12</span>,<span class="key">startTime</span>:<span class="integer">2006</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:bremen,<span class="key">id</span>:<span class="integer">13</span>,<span class="key">startTime</span>:<span class="integer">2004</span>,<span class="key">endTime</span>:<span class="integer">2007</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:baltimore,<span class="key">id</span>:<span class="integer">14</span>,<span class="key">startTime</span>:<span class="integer">2007</span>,<span class="key">endTime</span>:<span class="integer">2011</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:oakland,<span class="key">id</span>:<span class="integer">15</span>,<span class="key">startTime</span>:<span class="integer">2011</span>,<span class="key">endTime</span>:<span class="integer">2014</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:seattle,<span class="key">id</span>:<span class="integer">16</span>,<span class="key">startTime</span>:<span class="integer">2014</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:spremberg,<span class="key">id</span>:<span class="integer">17</span>,<span class="key">startTime</span>:<span class="integer">1982</span>,<span class="key">endTime</span>:<span class="integer">2005</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:kaiserslautern,<span class="key">id</span>:<span class="integer">18</span>,<span class="key">startTime</span>:<span class="integer">2005</span>,<span class="key">endTime</span>:<span class="integer">2009</span>,<span class="key">key</span>:location]
+==&gt;[<span class="key">value</span>:aachen,<span class="key">id</span>:<span class="integer">19</span>,<span class="key">startTime</span>:<span class="integer">2009</span>,<span class="key">key</span>:location]</code></pre>
 </div>
 </div>
 </div>
@@ -7954,17 +7953,20 @@ depending on whether there is or is not
         <span class="keyword">if</span> (TraversalHelper.onGraphComputer(traversal))
             <span class="keyword">return</span>;
 
-        TraversalHelper.getStepsOfClass(GraphStep.class, traversal).forEach(originalGraphStep -&gt; {
-            <span class="directive">final</span> TinkerGraphStep&lt;?,?&gt; tinkerGraphStep = <span class="keyword">new</span> TinkerGraphStep&lt;&gt;(originalGraphStep);
-            TraversalHelper.replaceStep(originalGraphStep, (Step) tinkerGraphStep, traversal);
+        <span class="keyword">for</span> (<span class="directive">final</span> GraphStep originalGraphStep : TraversalHelper.getStepsOfClass(GraphStep.class, traversal)) {
+            <span class="directive">final</span> TinkerGraphStep&lt;?, ?&gt; tinkerGraphStep = <span class="keyword">new</span> TinkerGraphStep&lt;&gt;(originalGraphStep);
+            TraversalHelper.replaceStep(originalGraphStep, tinkerGraphStep, traversal);
             Step&lt;?, ?&gt; currentStep = tinkerGraphStep.getNextStep();
             <span class="keyword">while</span> (currentStep <span class="keyword">instanceof</span> HasContainerHolder) {
-                ((HasContainerHolder) currentStep).getHasContainers().forEach(tinkerGraphStep::addHasContainer);
-                currentStep.getLabels().forEach(tinkerGraphStep::addLabel);
+                <span class="keyword">for</span> (<span class="directive">final</span> HasContainer hasContainer : ((HasContainerHolder) currentStep).getHasContainers()) {
+                    <span class="keyword">if</span> (!GraphStep.processHasContainerIds(tinkerGraphStep, hasContainer))
+                        tinkerGraphStep.addHasContainer(hasContainer);
+                }
+                TraversalHelper.copyLabels(currentStep, tinkerGraphStep, <span class="predefined-constant">false</span>);
                 traversal.removeStep(currentStep);
                 currentStep = currentStep.getNextStep();
             }
-        });
+        }
     }
 
     <span class="directive">public</span> <span class="directive">static</span> TinkerGraphStepStrategy instance() {
@@ -7991,6 +7993,97 @@ gremlin&gt; t.toString()
 ==&gt;[TinkerGraphStep(vertex,[name.eq(marko)])]</code></pre>
 </div>
 </div>
+<div class="paragraph">
+<p>Finally, here is a complicated traversal that has various components that are optimized by the default TinkerPop strategies.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>). <span class="comment">//</span><b>(1)</b>
+                 and(has(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>),filter(has(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>,gt(<span class="integer">20</span>)))). <span class="comment">//</span><b>(2)</b>
+           match(__.as(<span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>).has(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>,lt(<span class="integer">32</span>)), <span class="comment">//</span><b>(3)</b>
+                 __.as(<span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>).repeat(outE().inV()).times(<span class="integer">2</span>).as(<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>)). <span class="comment">//</span><b>(4)</b>
+             where(<span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>,neq(<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>)). <span class="comment">//</span><b>(5)</b>
+             where(__.as(<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>).both().count().is(gt(<span class="integer">1</span>))). <span class="comment">//</span><b>(6)</b>
+           select(<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>). <span class="comment">//</span><b>(7)</b>
+           groupCount().
+             by(out().count()). <span class="comment">//</span><b>(8)</b>
+           explain()
+==&gt;Traversal Explanation
+==========================================================================================================================================================================================================================================
+Original Traversal                 [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), MatchStep(AND,[[MatchStartStep(a), HasStep([age.lt(<span class="integer">32</span>)]
+                                      ), MatchEndStep], [MatchStartStep(a), RepeatStep([VertexStep(OUT,edge), EdgeVertexStep(IN), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)]]), WherePredicateStep(a,neq(b)), WhereTrav
+                                      ersalStep([WhereStartStep(b), VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
+
+ConnectiveStrategy           [D]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), MatchStep(AND,[[MatchStartStep(a), HasStep([age.lt(<span class="integer">32</span>)]
+                                      ), MatchEndStep], [MatchStartStep(a), RepeatStep([VertexStep(OUT,edge), EdgeVertexStep(IN), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)]]), WherePredicateStep(a,neq(b)), WhereTrav
+                                      ersalStep([WhereStartStep(b), VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
+IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), MatchStep(AND,[[MatchStartStep(a), HasStep([age.lt(<span class="integer">32</span>)]
+                                      ), MatchEndStep], [MatchStartStep(a), RepeatStep([VertexStep(OUT,vertex), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)]]), WherePredicateStep(a,neq(b)), WhereTraversalStep([WhereSt
+                                      artStep(b), VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
+AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), MatchStep(AND,[[MatchStartStep(a), HasStep([age.lt(<span class="integer">32</span>)]
+                                      ), MatchEndStep], [MatchStartStep(a), RepeatStep([VertexStep(OUT,vertex), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)]]), WherePredicateStep(a,neq(b)), WhereTraversalStep([WhereSt
+                                      artStep(b), VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+InlineFilterStrategy         [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko)]), HasStep([age.gt(<span class="integer">20</span>)])<span class="error">@</span>[a], HasStep([age.lt(<span class="integer">32</span>)]), MatchStep(AND,[[MatchStartStep(a), RepeatStep([VertexStep(OUT,vert
+                                      ex), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)]]), WherePredicateStep(a,neq(b)), WhereTraversalStep([WhereStartStep(b), VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]),
+                                      SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+MatchPredicateStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko)]), HasStep([age.gt(<span class="integer">20</span>)])<span class="error">@</span>[a], HasStep([age.lt(<span class="integer">32</span>)]), MatchStep(AND,[[MatchStartStep(a), RepeatStep([VertexStep(OUT,vert
+                                      ex), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexSte
+                                      p(BOTH,edge), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+FilterRankingStrategy        [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko)]), HasStep([age.gt(<span class="integer">20</span>)])<span class="error">@</span>[a], HasStep([age.lt(<span class="integer">32</span>)]), MatchStep(AND,[[MatchStartStep(a), RepeatStep([VertexStep(OUT,vert
+                                      ex), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexSte
+                                      p(BOTH,edge), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko)]), HasStep([age.gt(<span class="integer">20</span>)])<span class="error">@</span>[a], HasStep([age.lt(<span class="integer">32</span>)]), MatchStep(AND,[[MatchStartStep(a), VertexStep(OUT,vertex), NoOpBar
+                                      rierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartSt
+                                      ep, VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+PathRetractionStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko)]), HasStep([age.gt(<span class="integer">20</span>)])<span class="error">@</span>[a], HasStep([age.lt(<span class="integer">32</span>)]), MatchStep(AND,[[MatchStartStep(a), VertexStep(OUT,vertex), NoOpBar
+                                      rierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartSt
+                                      ep, VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+RangeByIsCountStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko)]), HasStep([age.gt(<span class="integer">20</span>)])<span class="error">@</span>[a], HasStep([age.lt(<span class="integer">32</span>)]), MatchStep(AND,[[MatchStartStep(a), VertexStep(OUT,vertex), NoOpBar
+                                      rierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartSt
+                                      ep, VertexStep(BOTH,edge), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">2</span>), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+TinkerGraphStepStrategy      [P]   [TinkerGraphStep(vertex,[~label.eq(person), name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex),
+                                      NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,edge), RangeGlobalSt
+                                      ep(<span class="integer">0</span>,<span class="integer">2</span>), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+ProfileStrategy              [F]   [TinkerGraphStep(vertex,[~label.eq(person), name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex),
+                                      NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,edge), RangeGlobalSt
+                                      ep(<span class="integer">0</span>,<span class="integer">2</span>), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+StandardVerificationStrategy [V]   [TinkerGraphStep(vertex,[~label.eq(person), name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex),
+                                      NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,edge), RangeGlobalSt
+                                      ep(<span class="integer">0</span>,<span class="integer">2</span>), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+
+Final Traversal                    [TinkerGraphStep(vertex,[~label.eq(person), name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex),
+                                      NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,edge), RangeGlobalSt
+                                      ep(<span class="integer">0</span>,<span class="integer">2</span>), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]</code></pre>
+</div>
+</div>
+<div class="colist arabic">
+<ol>
+<li>
+<p><code>TinkerGraphStepStrategy</code> pulls in <code>has()</code>-step predicates for global, graph-centric index lookups.</p>
+</li>
+<li>
+<p><code>InlineFilterStrategy</code> de-nests filters to increase the likelihood of filter concatenation and aggregation.</p>
+</li>
+<li>
+<p><code>InlineFilterStrategy</code> pulls out named predicates from <code>match()</code>-step to more easily allow provider strategies to use indices.</p>
+</li>
+<li>
+<p><code>RepeatUnrollStrategy</code> will unroll loops and <code>IncidentToAdjacentStrategy</code> will turn <code>outE().inV()</code>-patterns into <code>out()</code>.</p>
+</li>
+<li>
+<p><code>MatchPredicateStrategy</code> will pull in <code>where()</code>-steps so that they can be subjected to <code>match()</code>-steps runtime query optimizer.</p>
+</li>
+<li>
+<p><code>RangeByIsCountStrategy</code> will limit the traversal to only the number of traversers required for the <code>count().is(x)</code>-check.</p>
+</li>

[... 854 lines stripped ...]



Mime
View raw message