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 2016/09/22 21:19:15 UTC
svn commit: r1761999 [2/23] - in /tinkerpop/site:
docs/3.2.3-SNAPSHOT/dev/developer/ docs/3.2.3-SNAPSHOT/dev/provider/
docs/3.2.3-SNAPSHOT/recipes/ docs/3.2.3-SNAPSHOT/reference/
docs/3.2.3-SNAPSHOT/tutorials/the-gremlin-console/ docs/3.2.3-SNAPSHOT/up...
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=1761999&r1=1761998&r2=1761999&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html (original)
+++ tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html Thu Sep 22 21:19:13 2016
@@ -861,7 +861,7 @@ span.line-numbers { border-right: 1px so
<li><a href="#graph-traversal-steps">Graph Traversal Steps</a></li>
<li>
<ul class="sectlevel2">
-<li><a href="#lambda-steps">Lambda Steps</a></li>
+<li><a href="#general-steps">General Steps</a></li>
<li><a href="#addedge-step">AddEdge Step</a></li>
<li><a href="#addvertex-step">AddVertex Step</a></li>
<li><a href="#addproperty-step">AddProperty Step</a></li>
@@ -1997,11 +1997,11 @@ system providers for two purposes:</p>
gremlin> graph.features()
==>FEATURES
> GraphFeatures
->-- <span class="key">Computer</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">Transactions</span>: <span class="predefined-constant">false</span>
>-- <span class="key">Persistence</span>: <span class="predefined-constant">true</span>
>-- <span class="key">ConcurrentAccess</span>: <span class="predefined-constant">false</span>
>-- <span class="key">ThreadedTransactions</span>: <span class="predefined-constant">false</span>
->-- <span class="key">Transactions</span>: <span class="predefined-constant">false</span>
+>-- <span class="key">Computer</span>: <span class="predefined-constant">true</span>
> VariableFeatures
>-- <span class="key">Variables</span>: <span class="predefined-constant">true</span>
>-- <span class="key">BooleanValues</span>: <span class="predefined-constant">true</span>
@@ -2023,10 +2023,11 @@ gremlin> graph.features()
>-- <span class="key">LongArrayValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">StringArrayValues</span>: <span class="predefined-constant">true</span>
> VertexFeatures
->-- <span class="key">MultiProperties</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">MetaProperties</span>: <span class="predefined-constant">true</span>
>-- <span class="key">AddVertices</span>: <span class="predefined-constant">true</span>
>-- <span class="key">RemoveVertices</span>: <span class="predefined-constant">true</span>
->-- <span class="key">MetaProperties</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">MultiProperties</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
>-- <span class="key">AddProperty</span>: <span class="predefined-constant">true</span>
>-- <span class="key">RemoveProperty</span>: <span class="predefined-constant">true</span>
>-- <span class="key">NumericIds</span>: <span class="predefined-constant">true</span>
@@ -2034,8 +2035,8 @@ gremlin> graph.features()
>-- <span class="key">UuidIds</span>: <span class="predefined-constant">true</span>
>-- <span class="key">CustomIds</span>: <span class="predefined-constant">false</span>
>-- <span class="key">AnyIds</span>: <span class="predefined-constant">true</span>
->-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
> VertexPropertyFeatures
+>-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
>-- <span class="key">AddProperty</span>: <span class="predefined-constant">true</span>
>-- <span class="key">RemoveProperty</span>: <span class="predefined-constant">true</span>
>-- <span class="key">NumericIds</span>: <span class="predefined-constant">true</span>
@@ -2043,7 +2044,6 @@ gremlin> graph.features()
>-- <span class="key">UuidIds</span>: <span class="predefined-constant">true</span>
>-- <span class="key">CustomIds</span>: <span class="predefined-constant">false</span>
>-- <span class="key">AnyIds</span>: <span class="predefined-constant">true</span>
->-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
>-- <span class="predefined-type">Properties</span>: <span class="predefined-constant">true</span>
>-- <span class="key">BooleanValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">ByteValues</span>: <span class="predefined-constant">true</span>
@@ -2064,8 +2064,9 @@ gremlin> graph.features()
>-- <span class="key">LongArrayValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">StringArrayValues</span>: <span class="predefined-constant">true</span>
> EdgeFeatures
->-- <span class="key">RemoveEdges</span>: <span class="predefined-constant">true</span>
>-- <span class="key">AddEdges</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">RemoveEdges</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
>-- <span class="key">AddProperty</span>: <span class="predefined-constant">true</span>
>-- <span class="key">RemoveProperty</span>: <span class="predefined-constant">true</span>
>-- <span class="key">NumericIds</span>: <span class="predefined-constant">true</span>
@@ -2073,7 +2074,6 @@ gremlin> graph.features()
>-- <span class="key">UuidIds</span>: <span class="predefined-constant">true</span>
>-- <span class="key">CustomIds</span>: <span class="predefined-constant">false</span>
>-- <span class="key">AnyIds</span>: <span class="predefined-constant">true</span>
->-- <span class="key">UserSuppliedIds</span>: <span class="predefined-constant">true</span>
> EdgePropertyFeatures
>-- <span class="predefined-type">Properties</span>: <span class="predefined-constant">true</span>
>-- <span class="key">BooleanValues</span>: <span class="predefined-constant">true</span>
@@ -2352,9 +2352,7 @@ use cases include:</p>
gremlin> graph.variables()
==>variables[<span class="key">size</span>:<span class="integer">0</span>]
gremlin> 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>])
-==><span class="predefined-constant">null</span>
gremlin> 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>])
-==><span class="predefined-constant">null</span>
gremlin> graph.variables().keys()
==>systemAdmins
==>systemUsers
@@ -2365,7 +2363,6 @@ gremlin> graph.variables().get(<span
==>marko
==>josh
gremlin> graph.variables().remove(<span class="string"><span class="delimiter">'</span><span class="content">systemAdmins</span><span class="delimiter">'</span></span>)
-==><span class="predefined-constant">null</span>
gremlin> graph.variables().keys()
==>systemUsers</code></pre>
</div>
@@ -2581,8 +2578,7 @@ gremlin> graph.tx().submit {<span cla
==>v[<span class="integer">0</span>]
gremlin> graph.tx().submit {<span class="local-variable">it</span>.addVertex(<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">daniel</span><span class="delimiter">"</span></span>)}.exponentialBackoff(<span class="integer">10</span>)
==>v[<span class="integer">1</span>]
-gremlin> graph.close()
-==><span class="predefined-constant">null</span></code></pre>
+gremlin> graph.close()</code></pre>
</div>
</div>
<div class="paragraph">
@@ -2859,9 +2855,7 @@ gremlin> g = graph.traversal()
gremlin> f = <span class="keyword">new</span> <span class="predefined-type">ByteArrayOutputStream</span>()
==>
gremlin> graph.io(graphson()).writer().create().writeVertex(f, g.V(<span class="integer">1</span>).next(), BOTH)
-==><span class="predefined-constant">null</span>
-gremlin> f.close()
-==><span class="predefined-constant">null</span></code></pre>
+gremlin> f.close()</code></pre>
</div>
</div>
<div class="paragraph">
@@ -2940,11 +2934,9 @@ gremlin> g = graph.traversal()
gremlin> f = <span class="keyword">new</span> <span class="predefined-type">ByteArrayOutputStream</span>()
==>
gremlin> mapper = graph.io(graphson()).mapper().embedTypes(<span class="predefined-constant">true</span>).create()
-==>org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">52337</span>eb6
+==>org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">557</span>c837
gremlin> graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span class="integer">1</span>).next(), BOTH)
-==><span class="predefined-constant">null</span>
-gremlin> f.close()
-==><span class="predefined-constant">null</span></code></pre>
+gremlin> f.close()</code></pre>
</div>
</div>
<div class="paragraph">
@@ -3132,11 +3124,9 @@ gremlin> g = graph.traversal()
gremlin> f = <span class="keyword">new</span> <span class="predefined-type">ByteArrayOutputStream</span>()
==>
gremlin> mapper = graph.io(graphson()).mapper().version(GraphSONVersion.V2_0).create()
-==>org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">37</span>c9dadf
+==>org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">63</span>b5a020
gremlin> graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span class="integer">1</span>).next(), BOTH)
-==><span class="predefined-constant">null</span>
-gremlin> f.close()
-==><span class="predefined-constant">null</span></code></pre>
+gremlin> f.close()</code></pre>
</div>
</div>
<div class="paragraph">
@@ -3477,24 +3467,9 @@ the verbose syntax <code>__.in()</code>
</table>
</div>
<div class="sect2">
-<h3 id="lambda-steps">Lambda Steps</h3>
-<div class="admonitionblock warning">
-<table>
-<tr>
-<td class="icon">
-<div class="title">Warning</div>
-</td>
-<td class="content">
-Lambda steps are presented for educational purposes as they represent the foundational constructs of the
-Gremlin language. In practice, lambda steps should be avoided and traversal verification strategies exist to disallow t
-heir use unless explicitly "turned off." For more information on the problems with lambdas, please read
-<a href="#a-note-on-lambdas">A Note on Lambdas</a>.
-</td>
-</tr>
-</table>
-</div>
+<h3 id="general-steps">General Steps</h3>
<div class="paragraph">
-<p>There are four generic steps by which all other specific steps described later extend.</p>
+<p>There are five general steps, each having a traversal and a lambda representation, by which all other specific steps described later extend.</p>
</div>
<table class="tableblock frame-all grid-all" style="width:100%; ">
<colgroup>
@@ -3509,28 +3484,43 @@ heir use unless explicitly "turned off."
</thead>
<tbody>
<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>map(Function<Traverser<S>, E>)</code></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code>map(Traversal<S, E>)</code> <br> <code>map(Function<Traverser<S>, E>)</code></p></td>
<td class="tableblock halign-left valign-top"><p class="tableblock">map the traverser to some object of type <code>E</code> for the next step to process.</p></td>
</tr>
<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>flatMap(Function<Traverser<S>, Iterator<E>>)</code></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code>flatMap(Traversal<S, E>)</code> <br> <code>flatMap(Function<Traverser<S>, Iterator<E>>)</code></p></td>
<td class="tableblock halign-left valign-top"><p class="tableblock">map the traverser to an iterator of <code>E</code> objects that are streamed to the next step.</p></td>
</tr>
<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>filter(Predicate<Traverser<S>>)</code></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code>filter(Traversal<?, ?>)</code> <br> <code>filter(Predicate<Traverser<S>>)</code></p></td>
<td class="tableblock halign-left valign-top"><p class="tableblock">map the traverser to either true or false, where false will not pass the traverser to the next step.</p></td>
</tr>
<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>sideEffect(Consumer<Traverser<S>>)</code></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code>sideEffect(Traversal<S, S>)</code> <br> <code>sideEffect(Consumer<Traverser<S>>)</code></p></td>
<td class="tableblock halign-left valign-top"><p class="tableblock">perform some operation on the traverser and pass it to the next step.</p></td>
</tr>
<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>branch(Function<Traverser<S>,M>)</code></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code>branch(Traversal<S, M>)</code> <br> <code>branch(Function<Traverser<S>,M>)</code></p></td>
<td class="tableblock halign-left valign-top"><p class="tableblock">split the traverser to all the traversals indexed by the <code>M</code> token.</p></td>
</tr>
</tbody>
</table>
+<div class="admonitionblock warning">
+<table>
+<tr>
+<td class="icon">
+<div class="title">Warning</div>
+</td>
+<td class="content">
+Lambda steps are presented for educational purposes as they represent the foundational constructs of the
+Gremlin language. In practice, lambda steps should be avoided in favor of their traversals representation and traversal
+verification strategies exist to disallow their use unless explicitly "turned off." For more information on the problems
+with lambdas, please read <a href="#a-note-on-lambdas">A Note on Lambdas</a>.
+</td>
+</tr>
+</table>
+</div>
<div class="paragraph">
<p>The <code>Traverser<S></code> object provides access to:</p>
</div>
@@ -3582,6 +3572,10 @@ heir use unless explicitly "turned off."
gremlin> g.V(<span class="integer">1</span>).out().map {<span class="local-variable">it</span>.get().value(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)} <span class="comment">//</span><b>(2)</b>
==>lop
==>vadas
+==>josh
+gremlin> g.V(<span class="integer">1</span>).out().map(values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)) <span class="comment">//</span><b>(3)</b>
+==>lop
+==>vadas
==>josh</code></pre>
</div>
</div>
@@ -3593,6 +3587,9 @@ gremlin> g.V(<span class="integer">1<
<li>
<p>The same operation, but using a lambda to access the name property values.</p>
</li>
+<li>
+<p>Again the same operation, but using the traversal representation of <code>map()</code>.</p>
+</li>
</ol>
</div>
<div class="paragraph">
@@ -3605,7 +3602,12 @@ gremlin> g.V(<span class="integer">1<
==>v[<span class="integer">2</span>]
==>v[<span class="integer">4</span>]
==>v[<span class="integer">6</span>]
-gremlin> 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>(2)</b>
+gremlin> g.V().filter(label().is(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>)) <span class="comment">//</span><b>(2)</b>
+==>v[<span class="integer">1</span>]
+==>v[<span class="integer">2</span>]
+==>v[<span class="integer">4</span>]
+==>v[<span class="integer">6</span>]
+gremlin> 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>(3)</b>
==>v[<span class="integer">1</span>]
==>v[<span class="integer">2</span>]
==>v[<span class="integer">4</span>]
@@ -3618,6 +3620,9 @@ gremlin> g.V().hasLabel(<span class="
<p>A filter that only allows the vertex to pass if it has an age-property.</p>
</li>
<li>
+<p>The same operation, but using the traversal represention of <code>filter()</code>.</p>
+</li>
+<li>
<p>The more specific <code>has()</code>-step is implemented as a <code>filter()</code> with respective predicate.</p>
</li>
</ol>
@@ -3635,7 +3640,10 @@ v[<span class="integer">2</span>]
v[<span class="integer">4</span>]
==>v[<span class="integer">4</span>]
v[<span class="integer">6</span>]
-==>v[<span class="integer">6</span>]</code></pre>
+==>v[<span class="integer">6</span>]
+gremlin> g.V().sideEffect(outE().count().store(<span class="string"><span class="delimiter">"</span><span class="content">o</span><span class="delimiter">"</span></span>)).
+ sideEffect(inE().count().store(<span class="string"><span class="delimiter">"</span><span class="content">i</span><span class="delimiter">"</span></span>)).cap(<span class="string"><span class="delimiter">"</span><span class="content">o</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">i</span><span class="delimiter">"</span></span>) <span class="comment">//</span><b>(2)</b>
+==>[<span class="key">i</span>:[<span class="integer">0</span>,<span class="integer">0</span>,<span class="integer">1</span>,<span class="integer">1</span>,<span class="integer">1</span>,<span class="integer">3</span>],<span class="key">o</span>:[<span class="integer">3</span>,<span class="integer">0</span>,<span class="integer">0</span>,<span class="integer">0</span>,<span class="integer">2</span>,<span class="integer">1</span>]]</code></pre>
</div>
</div>
<div class="colist arabic">
@@ -3643,6 +3651,9 @@ v[<span class="integer">6</span>]
<li>
<p>Whatever enters <code>sideEffect()</code> is passed to the next step, but some intervening process can occur.</p>
</li>
+<li>
+<p>Compute the out- and in-degree for each vertex. Both <code>sideEffect()</code> are fed with the same vertex.</p>
+</li>
</ol>
</div>
<div class="paragraph">
@@ -3650,7 +3661,7 @@ v[<span class="integer">6</span>]
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().branch(values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)).
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().branch {<span class="local-variable">it</span>.get().value(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)}.
option(<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>, values(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>)).
option(none, values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)) <span class="comment">//</span><b>(1)</b>
==><span class="integer">29</span>
@@ -3659,9 +3670,18 @@ v[<span class="integer">6</span>]
==>josh
==>ripple
==>peter
+gremlin> g.V().branch(values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)).
+ option(<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>, values(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>)).
+ option(none, values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)) <span class="comment">//</span><b>(2)</b>
+==><span class="integer">29</span>
+==>vadas
+==>lop
+==>josh
+==>ripple
+==>peter
gremlin> g.V().choose(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>),
values(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>),
- values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)) <span class="comment">//</span><b>(2)</b>
+ values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)) <span class="comment">//</span><b>(3)</b>
==><span class="integer">29</span>
==>vadas
==>lop
@@ -3676,6 +3696,9 @@ gremlin> g.V().choose(has(<span class
<p>If the vertex is "marko", get his age, else get the name of the vertex.</p>
</li>
<li>
+<p>The same operation, but using the traversal represention of <code>branch()</code>.</p>
+</li>
+<li>
<p>The more specific boolean-based <code>choose()</code>-step is implemented as a <code>branch()</code>.</p>
</li>
</ol>
@@ -4020,17 +4043,16 @@ made more salient on a larger graph. The
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> graph = TinkerGraph.open()
==>tinkergraph[<span class="key">vertices</span>:<span class="integer">0</span> <span class="key">edges</span>:<span class="integer">0</span>]
gremlin> graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-==><span class="predefined-constant">null</span>
gremlin> g = graph.traversal()
==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">808</span> <span class="key">edges</span>:<span class="integer">8049</span>], standard]
gremlin> clockWithResult(<span class="integer">1</span>){g.V().both().both().both().count().next()} <span class="comment">//</span><b>(1)</b>
-==><span class="float">14317.232571999999</span>
+==><span class="float">8669.263931</span>
==><span class="integer">126653966</span>
gremlin> 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>
-==><span class="float">20.356651</span>
+==><span class="float">14.115905</span>
==><span class="integer">126653966</span>
gremlin> clockWithResult(<span class="integer">1</span>){g.V().both().barrier().both().barrier().both().barrier().count().next()} <span class="comment">//</span><b>(3)</b>
-==><span class="float">27.261338</span>
+==><span class="float">14.185149</span>
==><span class="integer">126653966</span></code></pre>
</div>
</div>
@@ -4061,11 +4083,10 @@ optimization scenario, but reduces the r
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> graph = TinkerGraph.open()
==>tinkergraph[<span class="key">vertices</span>:<span class="integer">0</span> <span class="key">edges</span>:<span class="integer">0</span>]
gremlin> graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-==><span class="predefined-constant">null</span>
gremlin> g = graph.traversal().withStrategies(LazyBarrierStrategy.instance())
==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">808</span> <span class="key">edges</span>:<span class="integer">8049</span>], standard]
gremlin> clockWithResult(<span class="integer">1</span>){g.V().both().both().both().count().next()}
-==><span class="float">17.443212</span>
+==><span class="float">11.988038</span>
==><span class="integer">126653966</span>
gremlin> g.V().both().both().both().count().iterate().toString() <span class="comment">//</span><b>(1)</b>
==>[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>
@@ -4287,9 +4308,8 @@ gremlin> g.V().hasLabel(<span class="
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().coin(<span class="float">0.5</span>)
==>v[<span class="integer">1</span>]
-==>v[<span class="integer">3</span>]
-==>v[<span class="integer">4</span>]
-==>v[<span class="integer">6</span>]
+==>v[<span class="integer">2</span>]
+==>v[<span class="integer">5</span>]
gremlin> g.V().coin(<span class="float">0.0</span>)
gremlin> g.V().coin(<span class="float">1.0</span>)
==>v[<span class="integer">1</span>]
@@ -4408,12 +4428,12 @@ has been seen or not.</p>
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> 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>)
-==>[<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">1</span>,<span class="key">name</span>:[marko]]
-==>[<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">2</span>,<span class="key">name</span>:[vadas]]
-==>[<span class="key">label</span>:software,<span class="key">id</span>:<span class="integer">3</span>,<span class="key">name</span>:[lop]]
-==>[<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">4</span>,<span class="key">name</span>:[josh]]
-==>[<span class="key">label</span>:software,<span class="key">id</span>:<span class="integer">5</span>,<span class="key">name</span>:[ripple]]
-==>[<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">6</span>,<span class="key">name</span>:[peter]]
+==>[<span class="key">name</span>:[marko],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">1</span>]
+==>[<span class="key">name</span>:[vadas],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">2</span>]
+==>[<span class="key">name</span>:[lop],<span class="key">label</span>:software,<span class="key">id</span>:<span class="integer">3</span>]
+==>[<span class="key">name</span>:[josh],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">4</span>]
+==>[<span class="key">name</span>:[ripple],<span class="key">label</span>:software,<span class="key">id</span>:<span class="integer">5</span>]
+==>[<span class="key">name</span>:[peter],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">6</span>]
gremlin> g.V().dedup().by(label).values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
==>marko
==>lop</code></pre>
@@ -4493,13 +4513,13 @@ Original Traversal [Grap
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>))]
-MatchPredicateStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-PathRetractionStrategy [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>))]
@@ -4593,10 +4613,10 @@ Whether a mid-traversal <code>V()</code>
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().has(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>, within(<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">vadas</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">josh</span><span class="delimiter">'</span></span>)).as(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).
V().has(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>, within(<span class="string"><span class="delimiter">'</span><span class="content">lop</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">ripple</span><span class="delimiter">'</span></span>)).addE(<span class="string"><span class="delimiter">'</span><span class="content">uses</span><span class="delimiter">'</span></span>).from(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).toString() <span class="comment">//</span><b>(1)</b>
-==>[GraphStep(vertex,<span class="type">[]</span>), HasStep([name.within([marko, vadas, josh])])<span class="error">@</span>[person], GraphStep(vertex,<span class="type">[]</span>), HasStep([name.within([lop, ripple])]), AddEdgeStep({label=[uses], ~from=[[SelectOneStep(person)]]})]
+==>[GraphStep(vertex,<span class="type">[]</span>), HasStep([name.within([marko, vadas, josh])])<span class="error">@</span>[person], GraphStep(vertex,<span class="type">[]</span>), HasStep([name.within([lop, ripple])]), AddEdgeStep({~from=[[SelectOneStep(person)]], label=[uses]})]
gremlin> g.V().has(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>, within(<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">vadas</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">josh</span><span class="delimiter">'</span></span>)).as(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).
V().has(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>, within(<span class="string"><span class="delimiter">'</span><span class="content">lop</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">ripple</span><span class="delimiter">'</span></span>)).addE(<span class="string"><span class="delimiter">'</span><span class="content">uses</span><span class="delimiter">'</span></span>).from(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).iterate().toString() <span class="comment">//</span><b>(2)</b>
-==>[TinkerGraphStep(vertex,[name.within([marko, vadas, josh])])<span class="error">@</span>[person], TinkerGraphStep(vertex,[name.within([lop, ripple])]), AddEdgeStep({label=[uses], ~from=[[SelectOneStep(person), NoOpBarrierStep(<span class="integer">2500</span>)]]})]</code></pre>
+==>[TinkerGraphStep(vertex,[name.within([marko, vadas, josh])])<span class="error">@</span>[person], TinkerGraphStep(vertex,[name.within([lop, ripple])]), AddEdgeStep({~from=[[SelectOneStep(person), NoOpBarrierStep(<span class="integer">2500</span>)]], label=[uses]})]</code></pre>
</div>
</div>
<div class="colist arabic">
@@ -5105,7 +5125,6 @@ songs which Jerry Garcia has both sung a
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-==><span class="predefined-constant">null</span>
gremlin> g = graph.traversal()
==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">808</span> <span class="key">edges</span>:<span class="integer">8049</span>], standard]
gremlin> g.V().match(
@@ -5313,7 +5332,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>
-==><span class="predefined-constant">null</span>
gremlin> traversal.toString() <span class="comment">//</span><b>(4)</b>
==>[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> traversal <span class="comment">// </span><b>(5)</b> <b>(6)</b>
@@ -5626,15 +5644,15 @@ gremlin> g.V().hasLabel(<span class="
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).order().by(shuffle)
+==>v[<span class="integer">2</span>]
==>v[<span class="integer">6</span>]
-==>v[<span class="integer">1</span>]
==>v[<span class="integer">4</span>]
-==>v[<span class="integer">2</span>]
+==>v[<span class="integer">1</span>]
gremlin> g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).order().by(shuffle)
-==>v[<span class="integer">2</span>]
-==>v[<span class="integer">4</span>]
==>v[<span class="integer">6</span>]
-==>v[<span class="integer">1</span>]</code></pre>
+==>v[<span class="integer">1</span>]
+==>v[<span class="integer">4</span>]
+==>v[<span class="integer">2</span>]</code></pre>
</div>
</div>
<div class="paragraph">
@@ -5707,19 +5725,19 @@ The <code>pageRank()</code>-step is a <c
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g = graph.traversal().withComputer()
==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">6</span> <span class="key">edges</span>:<span class="integer">6</span>], graphcomputer]
gremlin> 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>)
+==><span class="float">0.4018125</span>
==><span class="float">0.19250000000000003</span>
==><span class="float">0.19250000000000003</span>
+==><span class="float">0.23181250000000003</span>
==><span class="float">0.15000000000000002</span>
==><span class="float">0.15000000000000002</span>
-==><span class="float">0.4018125</span>
-==><span class="float">0.23181250000000003</span>
gremlin> 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>)
-==>[<span class="key">friendRank</span>:[<span class="float">0.21375000000000002</span>],<span class="key">name</span>:[vadas]]
==>[<span class="key">friendRank</span>:[<span class="float">0.21375000000000002</span>],<span class="key">name</span>:[josh]]
+==>[<span class="key">friendRank</span>:[<span class="float">0.21375000000000002</span>],<span class="key">name</span>:[vadas]]
==>[<span class="key">friendRank</span>:[<span class="float">0.15000000000000002</span>],<span class="key">name</span>:[marko]]
==>[<span class="key">friendRank</span>:[<span class="float">0.15000000000000002</span>],<span class="key">name</span>:[peter]]</code></pre>
</div>
@@ -5737,45 +5755,45 @@ gremlin> 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()
==>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]
-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]
-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]), 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]
-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]
-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]
-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]
-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]
-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)]
+
+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]
-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>
@@ -5927,7 +5945,7 @@ gremlin> g.V().peerPressure().by(<spa
gremlin> 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>)
-==>[<span class="integer">1</span>:[marko,josh,vadas],<span class="integer">6</span>:[peter]]</code></pre>
+==>[<span class="integer">1</span>:[marko,vadas,josh],<span class="integer">6</span>:[peter]]</code></pre>
</div>
</div>
</div>
@@ -5956,18 +5974,18 @@ profile results, but durations are not e
==>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.455</span> <span class="float">9.61</span>
-VertexStep(OUT,[created],vertex) <span class="integer">4</span> <span class="integer">4</span> <span class="float">0.527</span> <span class="float">11.13</span>
-VertexStep(BOTH,vertex) <span class="integer">10</span> <span class="integer">10</span> <span class="float">0.507</span> <span class="float">10.72</span>
-NoOpBarrierStep(<span class="integer">5000</span>) <span class="integer">10</span> <span class="integer">3</span> <span class="float">0.483</span> <span class="float">10.20</span>
-VertexStep(BOTH,vertex) <span class="integer">24</span> <span class="integer">7</span> <span class="float">0.361</span> <span class="float">7.63</span>
-NoOpBarrierStep(<span class="integer">5000</span>) <span class="integer">24</span> <span class="integer">5</span> <span class="float">0.442</span> <span class="float">9.33</span>
-VertexStep(BOTH,vertex) <span class="integer">58</span> <span class="integer">11</span> <span class="float">0.518</span> <span class="float">10.94</span>
-NoOpBarrierStep(<span class="integer">5000</span>) <span class="integer">58</span> <span class="integer">6</span> <span class="float">0.526</span> <span class="float">11.12</span>
-HasStep([~label.eq(person)]) <span class="integer">48</span> <span class="integer">4</span> <span class="float">0.330</span> <span class="float">6.98</span>
-PropertiesStep([age],value) <span class="integer">48</span> <span class="integer">4</span> <span class="float">0.263</span> <span class="float">5.56</span>
-SumGlobalStep <span class="integer">1</span> <span class="integer">1</span> <span class="float">0.320</span> <span class="float">6.77</span>
- >TOTAL - - <span class="float">4.738</span> -</code></pre>
+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>
+ >TOTAL - - <span class="float">0.623</span> -</code></pre>
</div>
</div>
<div class="paragraph">
@@ -6015,9 +6033,9 @@ gremlin> metrics = t.getSideEffects()
==>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.226</span> <span class="float">90.21</span>
-VertexStep(OUT,[created],vertex) <span class="integer">4</span> <span class="integer">4</span> <span class="float">0.024</span> <span class="float">9.79</span>
- >TOTAL - - <span class="float">0.251</span> -</code></pre>
+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>
+ >TOTAL - - -<span class="float">0.179</span> -</code></pre>
</div>
</div>
<div class="paragraph">
@@ -6169,8 +6187,8 @@ gremlin> 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>)
-==>[<span class="key">name</span>:[marko],<span class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
==>[<span class="key">name</span>:[peter],<span class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
+==>[<span class="key">name</span>:[marko],<span class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
==>[<span class="key">name</span>:[vadas],<span class="key">rank</span>:[<span class="float">0.19250000000000003</span>]]
==>[<span class="key">name</span>:[josh],<span class="key">rank</span>:[<span class="float">0.19250000000000003</span>]]</code></pre>
</div>
@@ -6438,14 +6456,14 @@ value is accessed (<code>sack()</code>).
==><span class="float">1.0</span>
==><span class="float">1.0</span>
gremlin> rand = <span class="keyword">new</span> <span class="predefined-type">Random</span>()
-==>java.util.Random<span class="error">@</span><span class="float">3d</span>fe520
+==>java.util.Random<span class="error">@</span><span class="float">6567d</span>e86
gremlin> g.withSack {rand.nextFloat()}.V().sack()
-==><span class="float">0.8255876</span>
-==><span class="float">0.1542666</span>
-==><span class="float">0.5551805</span>
-==><span class="float">0.32227212</span>
-==><span class="float">0.60015833</span>
-==><span class="float">0.414905</span></code></pre>
+==><span class="float">0.6391494</span>
+==><span class="float">0.8057445</span>
+==><span class="float">0.7621683</span>
+==><span class="float">0.85526294</span>
+==><span class="float">0.10751295</span>
+==><span class="float">0.51945925</span></code></pre>
</div>
</div>
<div class="paragraph">
@@ -6556,7 +6574,7 @@ gremlin> g.withBulk(<span class="pred
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> 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>)
-==><span class="float">1.0</span>
+==><span class="float">0.5</span>
gremlin> 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>)
==><span class="float">1.0</span>
gremlin> 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>)
@@ -6576,15 +6594,15 @@ the traverser never splits and continues
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> 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>)
-==>v[<span class="integer">2</span>]
+==>v[<span class="integer">4</span>]
gremlin> 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()
-==>[v[<span class="integer">1</span>],e[<span class="integer">9</span>][<span class="integer">1</span>-created-><span class="integer">3</span>],v[<span class="integer">3</span>],e[<span class="integer">11</span>][<span class="integer">4</span>-created-><span class="integer">3</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">5</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">5</span>]]
+==>[v[<span class="integer">1</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-><span class="integer">4</span>],v[<span class="integer">4</span>],e[<span class="integer">11</span>][<span class="integer">4</span>-created-><span class="integer">3</span>],v[<span class="integer">3</span>],e[<span class="integer">12</span>][<span class="integer">6</span>-created-><span class="integer">3</span>],v[<span class="integer">6</span>],e[<span class="integer">12</span>][<span class="integer">6</span>-created-><span class="integer">3</span>],v[<span class="integer">3</span>],e[<span class="integer">11</span>][<span class="integer">4</span>-created-><span class="integer">3</span>],v[<span class="integer">4</span>]]
gremlin> 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()
-==>[v[<span class="integer">1</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-><span class="integer">4</span>],v[<span class="integer">4</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-><span class="integer">4</span>],v[<span class="integer">1</span>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>],v[<span class="integer">2</span>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>],v[<span class="integer">1</span>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>],v[<span class="integer">2</span>],e[<span class="integer">7</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>],v[<span class="integer">1</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-><span class="integer">4</span>],v[<
span class="integer">4</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-><span class="integer">4</span>],v[<span class="integer">1</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-><span class="integer">4</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">5</span>]]</code></pre>
+==>[v[<span class="integer">1</span>],e[<span class="integer">8</span>][<span class="integer">1</span>-knows-><span class="integer">4</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">5</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">5</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">5</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="inte
ger">5</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">5</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">4</span>],e[<span class="integer">10</span>][<span class="integer">4</span>-created-><span class="integer">5</span>],v[<span class="integer">5</span>]]</code></pre>
</div>
</div>
</div>
@@ -6682,7 +6700,6 @@ ranking.</p>
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-==><span class="predefined-constant">null</span>
gremlin> g = graph.traversal()
==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">808</span> <span class="key">edges</span>:<span class="integer">8049</span>], standard]
gremlin> 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>).
@@ -6706,7 +6723,6 @@ gremlin> g.V().hasLabel(<span class="
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-==><span class="predefined-constant">null</span>
gremlin> g = graph.traversal()
==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">808</span> <span class="key">edges</span>:<span class="integer">8049</span>], standard]
gremlin> 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>
@@ -7095,7 +7111,7 @@ that can be used to time execution of a
==>v[<span class="integer">5</span>]=<span class="integer">1136688</span>
==>v[<span class="integer">6</span>]=<span class="integer">1136688</span>
gremlin> 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()}
-==><span class="float">4.547744</span>
+==><span class="float">1.335103</span>
gremlin> 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()
==>v[<span class="integer">1</span>]=<span class="integer">2744208</span>
==>v[<span class="integer">3</span>]=<span class="integer">2744208</span>
@@ -7104,7 +7120,7 @@ gremlin> g.V().repeat(timeLimit(<span
==>v[<span class="integer">5</span>]=<span class="integer">1136688</span>
==>v[<span class="integer">6</span>]=<span class="integer">1136688</span>
gremlin> 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()}
-==><span class="float">4.675629</span></code></pre>
+==><span class="float">1.218626</span></code></pre>
</div>
</div>
<div class="paragraph">
@@ -7302,30 +7318,30 @@ returned map.</p>
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> 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="key">label</span>:person,<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,<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,<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,<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">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>]
+==>[<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>]
+==>[<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>]
+==>[<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>]
gremlin> 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>)
-==>[<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">1</span>,<span class="key">name</span>:[marko]]
-==>[<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">7</span>,<span class="key">name</span>:[stephen]]
-==>[<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">8</span>,<span class="key">name</span>:[matthias]]
-==>[<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">9</span>,<span class="key">name</span>:[daniel]]
+==>[<span class="key">name</span>:[marko],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">1</span>]
+==>[<span class="key">name</span>:[stephen],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">7</span>]
+==>[<span class="key">name</span>:[matthias],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">8</span>]
+==>[<span class="key">name</span>:[daniel],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">9</span>]
gremlin> 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>)
-==>[<span class="key">id</span>:<span class="integer">6</span>,<span class="key">value</span>:san diego,<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]
-==>[<span class="key">id</span>:<span class="integer">7</span>,<span class="key">value</span>:santa cruz,<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]
-==>[<span class="key">id</span>:<span class="integer">8</span>,<span class="key">value</span>:brussels,<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]
-==>[<span class="key">id</span>:<span class="integer">9</span>,<span class="key">value</span>:santa fe,<span class="key">startTime</span>:<span class="integer">2005</span>,<span class="key">key</span>:location]
-==>[<span class="key">id</span>:<span class="integer">10</span>,<span class="key">value</span>:centreville,<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]
-==>[<span class="key">id</span>:<span class="integer">11</span>,<span class="key">value</span>:dulles,<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]
-==>[<span class="key">id</span>:<span class="integer">12</span>,<span class="key">value</span>:purcellville,<span class="key">startTime</span>:<span class="integer">2006</span>,<span class="key">key</span>:location]
-==>[<span class="key">id</span>:<span class="integer">13</span>,<span class="key">value</span>:bremen,<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]
-==>[<span class="key">id</span>:<span class="integer">14</span>,<span class="key">value</span>:baltimore,<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]
-==>[<span class="key">id</span>:<span class="integer">15</span>,<span class="key">value</span>:oakland,<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]
-==>[<span class="key">id</span>:<span class="integer">16</span>,<span class="key">value</span>:seattle,<span class="key">startTime</span>:<span class="integer">2014</span>,<span class="key">key</span>:location]
[... 929 lines stripped ...]