You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by sp...@apache.org on 2017/01/10 18:47:51 UTC

svn commit: r1778175 [3/22] - in /tinkerpop/site: docs/3.2.4-SNAPSHOT/dev/provider/ docs/3.2.4-SNAPSHOT/images/ docs/3.2.4-SNAPSHOT/recipes/ docs/3.2.4-SNAPSHOT/reference/ docs/3.2.4-SNAPSHOT/tutorials/the-gremlin-console/ javadocs/3.2.4-SNAPSHOT/core/...

Modified: tinkerpop/site/docs/3.2.4-SNAPSHOT/reference/index.html
URL: http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.4-SNAPSHOT/reference/index.html?rev=1778175&r1=1778174&r2=1778175&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.4-SNAPSHOT/reference/index.html (original)
+++ tinkerpop/site/docs/3.2.4-SNAPSHOT/reference/index.html Tue Jan 10 18:47:50 2017
@@ -2008,12 +2008,14 @@ gremlin> graph.features()
 ==>FEATURES
 > GraphFeatures
 &gt;-- <span class="key">Transactions</span>: <span class="predefined-constant">false</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">Computer</span>: <span class="predefined-constant">true</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; VariableFeatures
 &gt;-- <span class="key">Variables</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>
 &gt;-- <span class="key">DoubleValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">FloatValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">IntegerValues</span>: <span class="predefined-constant">true</span>
@@ -2029,33 +2031,33 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">FloatArrayValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">IntegerArrayValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">LongArrayValues</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">ByteValues</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">BooleanValues</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">DuplicateMultiProperties</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">AddVertices</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">MultiProperties</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>
 &gt;-- <span class="key">StringIds</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">UuidIds</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">UserSuppliedIds</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; 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>
 &gt;-- <span class="key">StringIds</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">UuidIds</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">UserSuppliedIds</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>
 &gt;-- <span class="key">DoubleValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">FloatValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">IntegerValues</span>: <span class="predefined-constant">true</span>
@@ -2071,8 +2073,6 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">FloatArrayValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">IntegerArrayValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">LongArrayValues</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">ByteValues</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">BooleanValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">StringArrayValues</span>: <span class="predefined-constant">true</span>
 &gt; EdgeFeatures
 &gt;-- <span class="key">RemoveEdges</span>: <span class="predefined-constant">true</span>
@@ -2082,11 +2082,13 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">NumericIds</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">StringIds</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">UuidIds</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">UserSuppliedIds</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>
+&gt;-- <span class="key">ByteValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">DoubleValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">FloatValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">IntegerValues</span>: <span class="predefined-constant">true</span>
@@ -2102,8 +2104,6 @@ gremlin&gt; graph.features()
 &gt;-- <span class="key">FloatArrayValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">IntegerArrayValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">LongArrayValues</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">ByteValues</span>: <span class="predefined-constant">true</span>
-&gt;-- <span class="key">BooleanValues</span>: <span class="predefined-constant">true</span>
 &gt;-- <span class="key">StringArrayValues</span>: <span class="predefined-constant">true</span>
 </code></pre>
 </div>
@@ -2363,9 +2363,7 @@ use cases include:</p>
 gremlin&gt; graph.variables()
 ==&gt;variables[<span class="key">size</span>:<span class="integer">0</span>]
 gremlin&gt; graph.variables().set(<span class="string"><span class="delimiter">'</span><span class="content">systemAdmins</span><span class="delimiter">'</span></span>,[<span class="string"><span class="delimiter">'</span><span class="content">stephen</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">peter</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">pavel</span><span class="delimiter">'</span></span>])
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; graph.variables().set(<span class="string"><span class="delimiter">'</span><span class="content">systemUsers</span><span class="delimiter">'</span></span>,[<span class="string"><span class="delimiter">'</span><span class="content">matthias</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">josh</span><span class="delimiter">'</span></span>])
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; graph.variables().keys()
 ==&gt;systemAdmins
 ==&gt;systemUsers
@@ -2376,7 +2374,6 @@ gremlin&gt; graph.variables().get(<span
 ==&gt;marko
 ==&gt;josh
 gremlin&gt; graph.variables().remove(<span class="string"><span class="delimiter">'</span><span class="content">systemAdmins</span><span class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; graph.variables().keys()
 ==&gt;systemUsers</code></pre>
 </div>
@@ -2592,8 +2589,7 @@ gremlin&gt; graph.tx().submit {<span cla
 ==&gt;v[<span class="integer">0</span>]
 gremlin&gt; graph.tx().submit {<span class="local-variable">it</span>.addVertex(<span class="string"><span class="delimiter">&quot;</span><span class="content">name</span><span class="delimiter">&quot;</span></span>,<span class="string"><span class="delimiter">&quot;</span><span class="content">daniel</span><span class="delimiter">&quot;</span></span>)}.exponentialBackoff(<span class="integer">10</span>)
 ==&gt;v[<span class="integer">1</span>]
-gremlin&gt; graph.close()
-==&gt;<span class="predefined-constant">null</span></code></pre>
+gremlin&gt; graph.close()</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2870,9 +2866,7 @@ gremlin&gt; g = graph.traversal()
 gremlin&gt; f = <span class="keyword">new</span> <span class="predefined-type">ByteArrayOutputStream</span>()
 ==&gt;
 gremlin&gt; graph.io(graphson()).writer().create().writeVertex(f, g.V(<span class="integer">1</span>).next(), BOTH)
-==&gt;<span class="predefined-constant">null</span>
-gremlin&gt; f.close()
-==&gt;<span class="predefined-constant">null</span></code></pre>
+gremlin&gt; f.close()</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2951,11 +2945,9 @@ 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">54</span>b57a4
+==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">4</span>a6fe0fa
 gremlin&gt; graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span class="integer">1</span>).next(), BOTH)
-==&gt;<span class="predefined-constant">null</span>
-gremlin&gt; f.close()
-==&gt;<span class="predefined-constant">null</span></code></pre>
+gremlin&gt; f.close()</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -3143,11 +3135,9 @@ 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">4471753</span>e
+==&gt;org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">46264</span>b96
 gremlin&gt; graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span class="integer">1</span>).next(), BOTH)
-==&gt;<span class="predefined-constant">null</span>
-gremlin&gt; f.close()
-==&gt;<span class="predefined-constant">null</span></code></pre>
+gremlin&gt; f.close()</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -4140,17 +4130,16 @@ made more salient on a larger graph. The
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; graph = TinkerGraph.open()
 ==&gt;tinkergraph[<span class="key">vertices</span>:<span class="integer">0</span> <span class="key">edges</span>:<span class="integer">0</span>]
 gremlin&gt; graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; g = graph.traversal().withoutStrategies(LazyBarrierStrategy) <span class="comment">//</span><b>(1)</b>
 ==&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>(2)</b>
-==&gt;<span class="float">10845.820883999999</span>
+==&gt;<span class="float">10057.896386</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>(3)</b>
-==&gt;<span class="float">20.426410999999998</span>
+==&gt;<span class="float">20.40533</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>(4)</b>
-==&gt;<span class="float">13.448696</span>
+==&gt;<span class="float">17.249624999999998</span>
 ==&gt;<span class="integer">126653966</span></code></pre>
 </div>
 </div>
@@ -4184,11 +4173,10 @@ optimization scenario with the added ben
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; graph = TinkerGraph.open()
 ==&gt;tinkergraph[<span class="key">vertices</span>:<span class="integer">0</span> <span class="key">edges</span>:<span class="integer">0</span>]
 gremlin&gt; graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; g = graph.traversal() <span class="comment">//</span><b>(1)</b>
 ==&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">14.526589999999999</span>
+==&gt;<span class="float">15.295553</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; g.V().both().both().both().count().iterate().toString() <span class="comment">//</span><b>(2)</b>
 ==&gt;[TinkerGraphStep(vertex,<span class="type">[]</span>), VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(BOTH,edge), CountGlobalStep]</code></pre>
@@ -4443,10 +4431,8 @@ gremlin&gt; g.V().choose(hasLabel(<span
 <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">3</span>]
-==&gt;v[<span class="integer">6</span>]
+==&gt;v[<span class="integer">5</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>]
@@ -5264,7 +5250,6 @@ songs which Jerry Garcia has both sung a
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 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; g.V().match(
@@ -5472,7 +5457,6 @@ optimizer within <code>match()</code>-st
                              __.as(<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>).in(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).as(<span class="string"><span class="delimiter">'</span><span class="content">c</span><span class="delimiter">'</span></span>)).
                              where(__.as(<span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>).as(<span class="string"><span class="delimiter">'</span><span class="content">c</span><span class="delimiter">'</span></span>)). <span class="comment">//</span><b>(2)</b>
                            select(<span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">c</span><span class="delimiter">'</span></span>).by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>); <span class="predefined-constant">null</span> <span class="comment">//</span><b>(3)</b>
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; traversal.toString() <span class="comment">//</span><b>(4)</b>
 ==&gt;[GraphStep(vertex,<span class="type">[]</span>), MatchStep(AND,[[MatchStartStep(a), HasStep([~label.eq(person)]), MatchEndStep], [MatchStartStep(a), VertexStep(OUT,[created],vertex), MatchEndStep(b)], [MatchStartStep(b), VertexStep(IN,[created],vertex), MatchEndStep(c)]]), WhereTraversalStep([WhereStartStep(a), VertexStep(OUT,[knows],vertex), WhereEndStep(c)]), SelectStep([a, c],[value(name)])]
 gremlin&gt; traversal <span class="comment">// </span><b>(5)</b> <b>(6)</b>
@@ -5785,15 +5769,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">6</span>]
 ==&gt;v[<span class="integer">1</span>]
-==&gt;v[<span class="integer">2</span>]
 ==&gt;v[<span class="integer">4</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">2</span>]
-==&gt;v[<span class="integer">4</span>]
-==&gt;v[<span class="integer">1</span>]</code></pre>
+==&gt;v[<span class="integer">1</span>]
+==&gt;v[<span class="integer">6</span>]
+==&gt;v[<span class="integer">4</span>]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -5866,19 +5850,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.19250000000000003</span>
 ==&gt;<span class="float">0.19250000000000003</span>
 ==&gt;<span class="float">0.15000000000000002</span>
 ==&gt;<span class="float">0.15000000000000002</span>
-==&gt;<span class="float">0.4018125</span>
 ==&gt;<span class="float">0.23181250000000003</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>:[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.21375000000000002</span>],<span class="key">name</span>:[vadas]]
 ==&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>
@@ -5896,49 +5880,49 @@ 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]]), PropertyMa
-                                      pStep([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]]), PropertyMa
-                                      pStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-LazyBarrierStrategy          [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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-TinkerGraphCountStrategy     [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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]), Traversa
-                                      lVertexProgramStep([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]]), PropertyMapS
+                                      tep([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]]), 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]
+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]
+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]
+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]
+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]
+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]
+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]), 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]
+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]
+LazyBarrierStrategy          [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]
+TinkerGraphCountStrategy     [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]
+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]
 
-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]), Traversa
-                                      lVertexProgramStep([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]), TraversalV
+                                      ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]</code></pre>
 </div>
 </div>
 </div>
@@ -6090,7 +6074,7 @@ gremlin&gt; g.V().peerPressure().by(<spa
 gremlin&gt; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).
            peerPressure().by(<span class="string"><span class="delimiter">'</span><span class="content">cluster</span><span class="delimiter">'</span></span>).
            group().by(<span class="string"><span class="delimiter">'</span><span class="content">cluster</span><span class="delimiter">'</span></span>).by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
-==&gt;[<span class="integer">1</span>:[marko,vadas,josh],<span class="integer">6</span>:[peter]]</code></pre>
+==&gt;[<span class="integer">1</span>:[marko,josh,vadas],<span class="integer">6</span>:[peter]]</code></pre>
 </div>
 </div>
 </div>
@@ -6119,18 +6103,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.078</span>     <span class="float">7.26</span>
-VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>           <span class="float">0.178</span>    <span class="float">16.62</span>
-VertexStep(BOTH,vertex)                                               <span class="integer">10</span>          <span class="integer">10</span>           <span class="float">0.100</span>     <span class="float">9.31</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">10</span>           <span class="integer">3</span>           <span class="float">0.095</span>     <span class="float">8.87</span>
-VertexStep(BOTH,vertex)                                               <span class="integer">24</span>           <span class="integer">7</span>           <span class="float">0.057</span>     <span class="float">5.33</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">24</span>           <span class="integer">5</span>           <span class="float">0.063</span>     <span class="float">5.92</span>
-VertexStep(BOTH,vertex)                                               <span class="integer">58</span>          <span class="integer">11</span>           <span class="float">0.079</span>     <span class="float">7.42</span>
-NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">58</span>           <span class="integer">6</span>           <span class="float">0.205</span>    <span class="float">19.13</span>
-HasStep([~label.eq(person)])                                          <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.051</span>     <span class="float">4.80</span>
-PropertiesStep([age],value)                                           <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.054</span>     <span class="float">5.11</span>
-SumGlobalStep                                                          <span class="integer">1</span>           <span class="integer">1</span>           <span class="float">0.109</span>    <span class="float">10.23</span>
-                                            &gt;TOTAL                     -           -           <span class="float">1.075</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                                             <span class="integer">6</span>           <span class="integer">6</span>           <span class="float">0.076</span>    <span class="float">12.03</span>
+VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>           <span class="float">0.098</span>    <span class="float">15.40</span>
+VertexStep(BOTH,vertex)                                               <span class="integer">10</span>          <span class="integer">10</span>           <span class="float">0.064</span>    <span class="float">10.02</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">10</span>           <span class="integer">3</span>           <span class="float">0.058</span>     <span class="float">9.08</span>
+VertexStep(BOTH,vertex)                                               <span class="integer">24</span>           <span class="integer">7</span>           <span class="float">0.028</span>     <span class="float">4.45</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">24</span>           <span class="integer">5</span>           <span class="float">0.029</span>     <span class="float">4.58</span>
+VertexStep(BOTH,vertex)                                               <span class="integer">58</span>          <span class="integer">11</span>           <span class="float">0.038</span>     <span class="float">6.02</span>
+NoOpBarrierStep(<span class="integer">2500</span>)                                                 <span class="integer">58</span>           <span class="integer">6</span>           <span class="float">0.067</span>    <span class="float">10.48</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.22</span>
+PropertiesStep([age],value)                                           <span class="integer">48</span>           <span class="integer">4</span>           <span class="float">0.038</span>     <span class="float">5.96</span>
+SumGlobalStep                                                          <span class="integer">1</span>           <span class="integer">1</span>           <span class="float">0.107</span>    <span class="float">16.77</span>
+                                            &gt;TOTAL                     -           -           <span class="float">0.639</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6178,9 +6162,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.079</span> -<span class="float">1144.30</span>
-VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>          -<span class="float">0.086</span>  <span class="float">1244.30</span>
-                                            &gt;TOTAL                     -           -          -<span class="float">0.006</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                                             <span class="integer">6</span>           <span class="integer">6</span>           <span class="float">0.070</span>  -<span class="float">257.94</span>
+VertexStep(OUT,[created],vertex)                                       <span class="integer">4</span>           <span class="integer">4</span>          -<span class="float">0.097</span>   <span class="float">357.94</span>
+                                            &gt;TOTAL                     -           -          -<span class="float">0.027</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6205,7 +6189,12 @@ the current state of the traverser.</p>
 ==&gt;lop
 ==&gt;lop
 ==&gt;lop
-==&gt;ripple</code></pre>
+==&gt;ripple
+gremlin&gt; g.V().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>).
+                        project(<span class="string"><span class="delimiter">'</span><span class="content">out</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">in</span><span class="delimiter">'</span></span>).
+                          by(outE().count()).
+                          by(inE().count())
+==&gt;[<span class="key">out</span>:<span class="integer">3</span>,<span class="keyword">in</span>:<span class="integer">0</span>]</code></pre>
 </div>
 </div>
 </div>
@@ -6601,14 +6590,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="integer">5295</span>a774
+==&gt;java.util.Random<span class="error">@</span><span class="integer">7320</span>bccc
 gremlin&gt; g.withSack {rand.nextFloat()}.V().sack()
-==&gt;<span class="float">0.9924713</span>
-==&gt;<span class="float">0.3433494</span>
-==&gt;<span class="float">0.43463868</span>
-==&gt;<span class="float">0.3005963</span>
-==&gt;<span class="float">0.6599379</span>
-==&gt;<span class="float">0.73584723</span></code></pre>
+==&gt;<span class="float">0.88565433</span>
+==&gt;<span class="float">0.32557082</span>
+==&gt;<span class="float">0.13471311</span>
+==&gt;<span class="float">0.3079176</span>
+==&gt;<span class="float">0.5479009</span>
+==&gt;<span class="float">0.68136716</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6719,12 +6708,12 @@ 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">0.4</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">0.5</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>)
-==&gt;<span class="float">0.4</span>
-==&gt;<span class="float">1.0</span></code></pre>
+==&gt;<span class="float">1.0</span>
+==&gt;<span class="float">0.4</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6739,15 +6728,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">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">9</span>][<span class="integer">1</span>-created-&gt;<span class="integer">3</span>],v[<span class="integer">3</span>]]
+==&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>]]
 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">11</span>][<span class="integer">4</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">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">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>]]</code></pre>
+==&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">9</span>][<span class="integer">1</span>-created-&gt;<span class="integer">3</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">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">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">12</span>][<span class="integer">6</span>-created-&gt;<span class="integer">3</span>],v[<span class="integer">6</span>]]</code></pre>
 </div>
 </div>
 </div>
@@ -6845,7 +6834,6 @@ ranking.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 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; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">song</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">followedBy</span><span class="delimiter">'</span></span>).groupCount().by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>).
@@ -6869,7 +6857,6 @@ gremlin&gt; g.V().hasLabel(<span class="
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-==&gt;<span class="predefined-constant">null</span>
 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; g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">song</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">sungBy</span><span class="delimiter">'</span></span>).groupCount().by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(1)</b>
@@ -7258,7 +7245,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.754899</span>
+==&gt;<span class="float">1.700046</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>
@@ -7267,7 +7254,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.916515</span></code></pre>
+==&gt;<span class="float">2.9760969999999998</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -8133,11 +8120,9 @@ to ensure the added step does not interf
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; t = g.V().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>); <span class="predefined-constant">null</span>
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; t.toString()
 ==&gt;[GraphStep(vertex,<span class="type">[]</span>), HasStep([name.eq(marko)])]
 gremlin&gt; t.iterate(); <span class="predefined-constant">null</span>
-==&gt;<span class="predefined-constant">null</span>
 gremlin&gt; t.toString()
 ==&gt;[TinkerGraphStep(vertex,[name.eq(marko)])]</code></pre>
 </div>
@@ -8179,64 +8164,64 @@ incorrect semantics.
              by(out().count()). <span class="comment">//</span><b>(9)</b>
            explain()
 ==&gt;Traversal Explanation
-==============================================================================================================================================================================================================================================
-Original Traversal                 [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), Matc
-                                      hStep(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)), WhereTraversalStep([WhereStartStep(b), VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountG
-                                      lobalStep])]
-
-ConnectiveStrategy           [D]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), Matc
-                                      hStep(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)), WhereTraversalStep([WhereStartStep(b), VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountG
-                                      lobalStep])]
-MatchPredicateStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), Matc
-                                      hStep(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)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]),
-                                       SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), Matc
-                                      hStep(AND,[[MatchStartStep(a), HasStep([age.lt(<span class="integer">32</span>)]), MatchEndStep], [MatchStartStep(a), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOp
-                                      BarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, Is
-                                      Step(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-PathRetractionStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), Matc
-                                      hStep(AND,[[MatchStartStep(a), HasStep([age.lt(<span class="integer">32</span>)]), MatchEndStep], [MatchStartStep(a), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOp
-                                      BarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, Is
-                                      Step(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-FilterRankingStrategy        [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), Matc
-                                      hStep(AND,[[MatchStartStep(a), HasStep([age.lt(<span class="integer">32</span>)]), MatchEndStep], [MatchStartStep(a), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOp
-                                      BarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, Is
-                                      Step(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-InlineFilterStrategy         [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],value)]), HasStep([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), Vert
-                                      exStep(OUT,edge), EdgeVertexStep(IN), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEnd
-                                      Step], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), Cou
-                                      ntGlobalStep])]
-IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],value)]), HasStep([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), Vert
-                                      exStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTrav
-                                      ersalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],property)]), HasStep([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), V
-                                      ertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereT
-                                      raversalStep([WhereStartStep, 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)]), TraversalFilterStep([PropertiesStep([name],property)]), HasStep([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), V
-                                      ertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereT
-                                      raversalStep([WhereStartStep, 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])]
-LazyBarrierStrategy          [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],property)]), HasStep([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), V
-                                      ertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereT
-                                      raversalStep([WhereStartStep, 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])]
-TinkerGraphCountStrategy     [P]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],property)]), HasStep([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), V
-                                      ertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereT
-                                      raversalStep([WhereStartStep, 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)]), TraversalFilterStep([PropertiesStep([name],property)]), HasStep([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), VertexSt
-                                      ep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversa
-                                      lStep([WhereStartStep, 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])]
-ProfileStrategy              [F]   [TinkerGraphStep(vertex,[~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],property)]), HasStep([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), VertexSt
-                                      ep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversa
-                                      lStep([WhereStartStep, 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])]
-StandardVerificationStrategy [V]   [TinkerGraphStep(vertex,[~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],property)]), HasStep([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), VertexSt
-                                      ep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversa
-                                      lStep([WhereStartStep, 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])]
-
-Final Traversal                    [TinkerGraphStep(vertex,[~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],property)]), HasStep([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), VertexSt
-                                      ep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversa
-                                      lStep([WhereStartStep, 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])]</code></pre>
+================================================================================================================================================================================================================================================
+Original Traversal                 [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), MatchS
+                                      tep(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)), WhereTraversalStep([WhereStartStep(b), VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalS
+                                      tep])]
+
+ConnectiveStrategy           [D]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), MatchS
+                                      tep(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)), WhereTraversalStep([WhereStartStep(b), VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalS
+                                      tep])]
+MatchPredicateStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), MatchS
+                                      tep(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)]
+                                      , [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), Selec
+                                      tOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
+RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), MatchS
+                                      tep(AND,[[MatchStartStep(a), HasStep([age.lt(<span class="integer">32</span>)]), MatchEndStep], [MatchStartStep(a), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarr
+                                      ierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(g
+                                      t(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
+PathRetractionStrategy       [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), MatchS
+                                      tep(AND,[[MatchStartStep(a), HasStep([age.lt(<span class="integer">32</span>)]), MatchEndStep], [MatchStartStep(a), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarr
+                                      ierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(g
+                                      t(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
+FilterRankingStrategy        [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), AndStep([[TraversalFilterStep([PropertiesStep([name],value)])], [HasStep([name.eq(marko)])], [TraversalFilterStep([HasStep([age.gt(<span class="integer">20</span>)])])]]), MatchS
+                                      tep(AND,[[MatchStartStep(a), HasStep([age.lt(<span class="integer">32</span>)]), MatchEndStep], [MatchStartStep(a), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarr
+                                      ierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(g
+                                      t(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
+InlineFilterStrategy         [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],value)]), HasStep([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), Vertex
+                                      Step(OUT,edge), EdgeVertexStep(IN), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,edge), EdgeVertexStep(IN), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep
+                                      ], [MatchStartStep(b), WhereTraversalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlob
+                                      alStep])]
+IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],value)]), HasStep([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), Vertex
+                                      Step(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">2500</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversa
+                                      lStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]

[... 1017 lines stripped ...]