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/06/06 01:42:43 UTC
svn commit: r1797721 [2/3] - in /tinkerpop/site:
docs/3.2.5-SNAPSHOT/dev/developer/ docs/3.2.5-SNAPSHOT/dev/provider/
docs/3.2.5-SNAPSHOT/recipes/ docs/3.2.5-SNAPSHOT/reference/
javadocs/3.2.5-SNAPSHOT/full/org/apache/tinkerpop/gremlin/process/traversal/
Modified: tinkerpop/site/docs/3.2.5-SNAPSHOT/reference/index.html
URL: http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.5-SNAPSHOT/reference/index.html?rev=1797721&r1=1797720&r2=1797721&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.5-SNAPSHOT/reference/index.html (original)
+++ tinkerpop/site/docs/3.2.5-SNAPSHOT/reference/index.html Tue Jun 6 01:42:43 2017
@@ -864,6 +864,15 @@ span.line-numbers { border-right: 1px so
<li><a href="#general-steps">General Steps</a></li>
<li><a href="#terminal-steps">Terminal 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>
+<li><a href="#aggregate-step">Aggregate Step</a></li>
+<li><a href="#and-step">And Step</a></li>
+<li><a href="#as-step">As Step</a></li>
+<li><a href="#barrier-step">Barrier Step</a></li>
+<li><a href="#by-step">By Step</a></li>
+<li><a href="#cap-step">Cap Step</a></li>
+<li><a href="#choose-step">Choose Step</a></li>
<li><a href="#coalesce-step">Coalesce Step</a></li>
<li><a href="#coin-step">Coin Step</a></li>
<li><a href="#constant-step">Constant Step</a></li>
@@ -2021,12 +2030,20 @@ gremlin> graph.features()
==>FEATURES
> GraphFeatures
>-- <span class="key">Transactions</span>: <span class="predefined-constant">false</span>
->-- <span class="key">Computer</span>: <span class="predefined-constant">true</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">Computer</span>: <span class="predefined-constant">true</span>
> VariableFeatures
>-- <span class="key">Variables</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">DoubleArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">FloatArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">IntegerArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">LongArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">StringArrayValues</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>
+>-- <span class="key">DoubleValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">FloatValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">IntegerValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">LongValues</span>: <span class="predefined-constant">true</span>
@@ -2037,20 +2054,13 @@ gremlin> graph.features()
>-- <span class="key">UniformListValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">BooleanArrayValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">ByteArrayValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">DoubleArrayValues</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>
->-- <span class="key">DoubleValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">FloatArrayValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">IntegerArrayValues</span>: <span class="predefined-constant">true</span>
->-- <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">RemoveVertices</span>: <span class="predefined-constant">true</span>
>-- <span class="key">DuplicateMultiProperties</span>: <span class="predefined-constant">true</span>
>-- <span class="key">AddVertices</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>
@@ -2058,8 +2068,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>
@@ -2067,8 +2077,15 @@ 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">DoubleArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">FloatArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">IntegerArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">LongArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">StringArrayValues</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>
+>-- <span class="key">DoubleValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">FloatValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">IntegerValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">LongValues</span>: <span class="predefined-constant">true</span>
@@ -2079,17 +2096,10 @@ gremlin> graph.features()
>-- <span class="key">UniformListValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">BooleanArrayValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">ByteArrayValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">DoubleArrayValues</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>
->-- <span class="key">DoubleValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">FloatArrayValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">IntegerArrayValues</span>: <span class="predefined-constant">true</span>
->-- <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">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>
@@ -2097,9 +2107,16 @@ 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">DoubleArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">FloatArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">IntegerArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">LongArrayValues</span>: <span class="predefined-constant">true</span>
+>-- <span class="key">StringArrayValues</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>
+>-- <span class="key">DoubleValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">FloatValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">IntegerValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">LongValues</span>: <span class="predefined-constant">true</span>
@@ -2110,14 +2127,6 @@ gremlin> graph.features()
>-- <span class="key">UniformListValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">BooleanArrayValues</span>: <span class="predefined-constant">true</span>
>-- <span class="key">ByteArrayValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">DoubleArrayValues</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>
->-- <span class="key">DoubleValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">FloatArrayValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">IntegerArrayValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">LongArrayValues</span>: <span class="predefined-constant">true</span>
->-- <span class="key">StringArrayValues</span>: <span class="predefined-constant">true</span>
</code></pre>
</div>
</div>
@@ -2985,7 +2994,7 @@ 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">21983453</span>
+==>org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="integer">503996</span>ab
gremlin> graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span class="integer">1</span>).next(), BOTH)
gremlin> f.close()</code></pre>
</div>
@@ -3175,7 +3184,7 @@ 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">63</span>bd5ea
+==>org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper<span class="error">@</span><span class="float">34e0</span>a965
gremlin> graph.io(graphson()).writer().mapper(mapper).create().writeVertex(f, g.V(<span class="integer">1</span>).next(), BOTH)
gremlin> f.close()</code></pre>
</div>
@@ -3885,18 +3894,450 @@ gremlin> g.V().match(
__.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">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>),
__.as(<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>).out(<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>)).
addE(<span class="string"><span class="delimiter">'</span><span class="content">friendlyCollaborator</span><span class="delimiter">'</span></span>).from(<span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>).to(<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>).
- property(id,<span class="integer">13</span>).property(<span class="string"><span class="delimiter">'</span><span class="content">project</span><span class="delimiter">'</span></span>,select(<span class="string"><span class="delimiter">'</span><span class="content">c</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>(5)</b>
- elect the objects labeled <span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span> and <span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span> from the path.<span class="string"><span class="delimiter">'</span></span><span class="error">
-</span> l(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).
+ property(id,<span class="integer">23</span>).property(<span class="string"><span class="delimiter">'</span><span class="content">project</span><span class="delimiter">'</span></span>,select(<span class="string"><span class="delimiter">'</span><span class="content">c</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>(5)</b>
+==>e[<span class="integer">23</span>][<span class="integer">1</span>-friendlyCollaborator-><span class="integer">4</span>]
+gremlin> g.E(<span class="integer">23</span>).valueMap()
+==>[<span class="key">project</span>:lop]</code></pre>
+</div>
+</div>
+<div class="colist arabic">
+<ol>
+<li>
+<p>Add a co-developer edge with a year-property between marko and his collaborators.</p>
+</li>
+<li>
+<p>Add incoming createdBy edges from the josh-vertex to the lop- and ripple-vertices.</p>
+</li>
+<li>
+<p>Add an inverse createdBy edge for all created edges.</p>
+</li>
+<li>
+<p>The newly created edge is a traversable object.</p>
+</li>
+<li>
+<p>Two arbitrary bindings in a traversal can be joined <code>from()</code>→<code>to()</code>, where <code>id</code> can be provided for graphs that
+supports user provided ids.</p>
+</li>
+</ol>
+</div>
+</div>
+<div class="sect2">
+<h3 id="addvertex-step">AddVertex Step</h3>
+<div class="paragraph">
+<p>The <code>addV()</code>-step is used to add vertices to the graph (<strong>map</strong>/<strong>sideEffect</strong>). For every incoming object, a vertex is
+created. Moreover, <code>GraphTraversalSource</code> maintains an <code>addV()</code> method.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.addV(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).property(<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">stephen</span><span class="delimiter">'</span></span>)
+==>v[<span class="integer">13</span>]
+gremlin> g.V().values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
+==>marko
+==>vadas
+==>lop
+==>josh
+==>ripple
+==>peter
+==>stephen
+gremlin> g.V().outE(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>).addV().property(<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">nothing</span><span class="delimiter">'</span></span>)
+==>v[<span class="integer">15</span>]
+==>v[<span class="integer">17</span>]
+gremlin> 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">nothing</span><span class="delimiter">'</span></span>)
+==>v[<span class="integer">17</span>]
+==>v[<span class="integer">15</span>]
+gremlin> 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">nothing</span><span class="delimiter">'</span></span>).bothE()</code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
+<h3 id="addproperty-step">AddProperty Step</h3>
+<div class="paragraph">
+<p>The <code>property()</code>-step is used to add properties to the elements of the graph (<strong>sideEffect</strong>). Unlike <code>addV()</code> and
+<code>addE()</code>, <code>property()</code> is a full sideEffect step in that it does not return the property it created, but the element
+that streamed into it. Moreover, if <code>property()</code> follows an <code>addV()</code> or <code>addE()</code>, then it is "folded" into the
+previous step to enable vertex and edge creation with all its properties in one creation operation.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V(<span class="integer">1</span>).property(<span class="string"><span class="delimiter">'</span><span class="content">country</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">usa</span><span class="delimiter">'</span></span>)
+==>v[<span class="integer">1</span>]
+gremlin> g.V(<span class="integer">1</span>).property(<span class="string"><span class="delimiter">'</span><span class="content">city</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">santa fe</span><span class="delimiter">'</span></span>).property(<span class="string"><span class="delimiter">'</span><span class="content">state</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">new mexico</span><span class="delimiter">'</span></span>).valueMap()
+==>[<span class="key">country</span>:[usa],<span class="key">city</span>:[santa fe],<span class="key">name</span>:[marko],<span class="key">state</span>:[<span class="keyword">new</span> mexico],<span class="key">age</span>:[<span class="integer">29</span>]]
+gremlin> g.V(<span class="integer">1</span>).property(list,<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>,<span class="integer">35</span>) <span class="comment">//</span><b>(1)</b>
+==>v[<span class="integer">1</span>]
+gremlin> g.V(<span class="integer">1</span>).valueMap()
+==>[<span class="key">country</span>:[usa],<span class="key">city</span>:[santa fe],<span class="key">name</span>:[marko],<span class="key">state</span>:[<span class="keyword">new</span> mexico],<span class="key">age</span>:[<span class="integer">29</span>,<span class="integer">35</span>]]
+gremlin> g.V(<span class="integer">1</span>).property(<span class="string"><span class="delimiter">'</span><span class="content">friendWeight</span><span class="delimiter">'</span></span>,outE(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>).values(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>).sum(),<span class="string"><span class="delimiter">'</span><span class="content">acl</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">private</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(2)</b>
+==>v[<span class="integer">1</span>]
+gremlin> g.V(<span class="integer">1</span>).properties(<span class="string"><span class="delimiter">'</span><span class="content">friendWeight</span><span class="delimiter">'</span></span>).valueMap() <span class="comment">//</span><b>(3)</b>
+==>[<span class="key">acl</span>:<span class="directive">private</span>]</code></pre>
+</div>
+</div>
+<div class="colist arabic">
+<ol>
+<li>
+<p>For vertices, a cardinality can be provided for <a href="#vertex-properties">vertex properties</a>.</p>
+</li>
+<li>
+<p>It is possible to select the property value (as well as key) via a traversal.</p>
+</li>
+<li>
+<p>For vertices, the <code>property()</code>-step can add meta-properties.</p>
+</li>
+</ol>
+</div>
+</div>
+<div class="sect2">
+<h3 id="aggregate-step">Aggregate Step</h3>
+<div class="imageblock">
+<div class="content">
+<img src="../images/aggregate-step.png" alt="aggregate step" width="800">
+</div>
+</div>
+<div class="paragraph">
+<p>The <code>aggregate()</code>-step (<strong>sideEffect</strong>) is used to aggregate all the objects at a particular point of traversal into a
+<code>Collection</code>. The step uses <a href="http://en.wikipedia.org/wiki/Eager_evaluation">eager evaluation</a> in that no objects
+continue on until all previous objects have been fully aggregated (as opposed to <a href="#store-step"><code>store()</code></a> which
+<a href="http://en.wikipedia.org/wiki/Lazy_evaluation">lazily</a> fills a collection). The eager evaluation nature is crucial
+in situations where everything at a particular point is required for future computation. An example is provided below.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V(<span class="integer">1</span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(1)</b>
+==>v[<span class="integer">3</span>]
+gremlin> g.V(<span class="integer">1</span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).aggregate(<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(2)</b>
+==>v[<span class="integer">3</span>]
+gremlin> g.V(<span class="integer">1</span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).aggregate(<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>).in(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(3)</b>
+==>v[<span class="integer">1</span>]
+==>v[<span class="integer">4</span>]
+==>v[<span class="integer">6</span>]
+gremlin> g.V(<span class="integer">1</span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).aggregate(<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>).in(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(4)</b>
+==>v[<span class="integer">3</span>]
+==>v[<span class="integer">5</span>]
+==>v[<span class="integer">3</span>]
+==>v[<span class="integer">3</span>]
+gremlin> g.V(<span class="integer">1</span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).aggregate(<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>).in(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).
+ where(without(<span class="string"><span class="delimiter">'</span><span class="content">x</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>(5)</b>
+==>ripple</code></pre>
+</div>
+</div>
+<div class="colist arabic">
+<ol>
+<li>
+<p>What has marko created?</p>
+</li>
+<li>
+<p>Aggregate all his creations.</p>
+</li>
+<li>
+<p>Who are marko’s collaborators?</p>
+</li>
+<li>
+<p>What have marko’s collaborators created?</p>
+</li>
+<li>
+<p>What have marko’s collaborators created that he hasn’t created?</p>
+</li>
+</ol>
+</div>
+<div class="paragraph">
+<p>In <a href="http://en.wikipedia.org/wiki/Recommender_system">recommendation systems</a>, the above pattern is used:</p>
+</div>
+<div class="literalblock">
+<div class="content">
+<pre>"What has userA liked? Who else has liked those things? What have they liked that userA hasn't already liked?"</pre>
+</div>
+</div>
+<div class="paragraph">
+<p>Finally, <code>aggregate()</code>-step can be modulated via <code>by()</code>-projection.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().out(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>).aggregate(<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>).cap(<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>)
+==>[v[<span class="integer">2</span>],v[<span class="integer">4</span>]]
+gremlin> g.V().out(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>).aggregate(<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>).by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>).cap(<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>)
+==>[vadas,josh]</code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
+<h3 id="and-step">And Step</h3>
+<div class="paragraph">
+<p>The <code>and()</code>-step ensures that all provided traversals yield a result (<strong>filter</strong>). Please see <a href="#or-step"><code>or()</code></a> for or-semantics.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().and(
+ outE(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>),
+ values(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>).is(lt(<span class="integer">30</span>))).
+ values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
+==>marko</code></pre>
+</div>
+</div>
+<div class="paragraph">
+<p>The <code>and()</code>-step can take an arbitrary number of traversals. All traversals must produce at least one output for the
+original traverser to pass to the next step.</p>
+</div>
+<div class="paragraph">
+<p>An <a href="http://en.wikipedia.org/wiki/Infix_notation">infix notation</a> can be used as well. Though, with infix notation,
+only two traversals can be and’d together.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().where(outE(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).and().outE(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>)).values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
+==>marko</code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
+<h3 id="as-step">As Step</h3>
+<div class="paragraph">
+<p>The <code>as()</code>-step is not a real step, but a "step modulator" similar to <a href="#by-step"><code>by()</code></a> and <a href="#option-step"><code>option()</code></a>.
+With <code>as()</code>, it is possible to provide a label to the step that can later be accessed by steps and data structures
+that make use of such labels — e.g., <a href="#select-step"><code>select()</code></a>, <a href="#match-step"><code>match()</code></a>, and path.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().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">created</span><span class="delimiter">'</span></span>).as(<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>).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">b</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(1)</b>
+==>[<span class="key">a</span>:v[<span class="integer">1</span>],<span class="key">b</span>:v[<span class="integer">3</span>]]
+==>[<span class="key">a</span>:v[<span class="integer">4</span>],<span class="key">b</span>:v[<span class="integer">5</span>]]
+==>[<span class="key">a</span>:v[<span class="integer">4</span>],<span class="key">b</span>:v[<span class="integer">3</span>]]
+==>[<span class="key">a</span>:v[<span class="integer">6</span>],<span class="key">b</span>:v[<span class="integer">3</span>]]
+gremlin> g.V().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">created</span><span class="delimiter">'</span></span>).as(<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>).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">b</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="comment">//</span><b>(2)</b>
+==>[<span class="key">a</span>:marko,<span class="key">b</span>:lop]
+==>[<span class="key">a</span>:josh,<span class="key">b</span>:ripple]
+==>[<span class="key">a</span>:josh,<span class="key">b</span>:lop]
+==>[<span class="key">a</span>:peter,<span class="key">b</span>:lop]</code></pre>
+</div>
+</div>
+<div class="colist arabic">
+<ol>
+<li>
+<p>Select the objects labeled "a" and "b" from the path.</p>
+</li>
+<li>
+<p>Select the objects labeled "a" and "b" from the path and, for each object, project its name value.</p>
+</li>
+</ol>
+</div>
+<div class="paragraph">
+<p>A step can have any number of labels associated with it. This is useful for referencing the same step multiple times in a future step.</p>
+</div>
+<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">software</span><span class="delimiter">'</span></span>).as(<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">b</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">c</span><span class="delimiter">'</span></span>).
+ 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">b</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>).
+ by(<span class="string"><span class="delimiter">'</span><span class="content">lang</span><span class="delimiter">'</span></span>).
+ by(__.in(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>).fold())
+==>[<span class="key">a</span>:lop,<span class="key">b</span>:java,<span class="key">c</span>:[marko,josh,peter]]
+==>[<span class="key">a</span>:ripple,<span class="key">b</span>:java,<span class="key">c</span>:[josh]]</code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
+<h3 id="barrier-step">Barrier Step</h3>
+<div class="paragraph">
+<p>The <code>barrier()</code>-step (<strong>barrier</strong>) turns the lazy traversal pipeline into a bulk-synchronous pipeline. This step is
+useful in the following situations:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>When everything prior to <code>barrier()</code> needs to be executed before moving onto the steps after the <code>barrier()</code> (i.e. ordering).</p>
+</li>
+<li>
+<p>When "stalling" the traversal may lead to a "bulking optimization" in traversals that repeatedly touch many of the same elements (i.e. optimizing).</p>
+</li>
+</ul>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().sideEffect{println <span class="string"><span class="delimiter">"</span><span class="content">first: </span><span class="inline"><span class="inline-delimiter">${</span><span class="local-variable">it</span><span class="inline-delimiter">}</span></span><span class="delimiter">"</span></span>}.sideEffect{println <span class="string"><span class="delimiter">"</span><span class="content">second: </span><span class="inline"><span class="inline-delimiter">${</span><span class="local-variable">it</span><span class="inline-delimiter">}</span></span><span class="delimiter">"</span></span>}.iterate()
+<span class="key">first</span>: v[<span class="integer">1</span>]
+<span class="key">second</span>: v[<span class="integer">1</span>]
+<span class="key">first</span>: v[<span class="integer">2</span>]
+<span class="key">second</span>: v[<span class="integer">2</span>]
+<span class="key">first</span>: v[<span class="integer">3</span>]
+<span class="key">second</span>: v[<span class="integer">3</span>]
+<span class="key">first</span>: v[<span class="integer">4</span>]
+<span class="key">second</span>: v[<span class="integer">4</span>]
+<span class="key">first</span>: v[<span class="integer">5</span>]
+<span class="key">second</span>: v[<span class="integer">5</span>]
+<span class="key">first</span>: v[<span class="integer">6</span>]
+<span class="key">second</span>: v[<span class="integer">6</span>]
+gremlin> g.V().sideEffect{println <span class="string"><span class="delimiter">"</span><span class="content">first: </span><span class="inline"><span class="inline-delimiter">${</span><span class="local-variable">it</span><span class="inline-delimiter">}</span></span><span class="delimiter">"</span></span>}.barrier().sideEffect{println <span class="string"><span class="delimiter">"</span><span class="content">second: </span><span class="inline"><span class="inline-delimiter">${</span><span class="local-variable">it</span><span class="inline-delimiter">}</span></span><span class="delimiter">"</span></span>}.iterate()
+<span class="key">first</span>: v[<span class="integer">1</span>]
+<span class="key">first</span>: v[<span class="integer">2</span>]
+<span class="key">first</span>: v[<span class="integer">3</span>]
+<span class="key">first</span>: v[<span class="integer">4</span>]
+<span class="key">first</span>: v[<span class="integer">5</span>]
+<span class="key">first</span>: v[<span class="integer">6</span>]
+<span class="key">second</span>: v[<span class="integer">1</span>]
+<span class="key">second</span>: v[<span class="integer">2</span>]
+<span class="key">second</span>: v[<span class="integer">3</span>]
+<span class="key">second</span>: v[<span class="integer">4</span>]
+<span class="key">second</span>: v[<span class="integer">5</span>]
+<span class="key">second</span>: v[<span class="integer">6</span>]</code></pre>
+</div>
+</div>
+<div class="paragraph">
+<p>The theory behind a "bulking optimization" is simple. If there are one million traversers at vertex 1, then there is
+no need to calculate one million <code>both()</code>-computations. Instead, represent those one million traversers as a single
+traverser with a <code>Traverser.bulk()</code> equal to one million and execute <code>both()</code> once. A bulking optimization example is
+made more salient on a larger graph. Therefore, the example below leverages the <a href="#grateful-dead">Grateful Dead graph</a>.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<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>)
+gremlin> g = graph.traversal().withoutStrategies(LazyBarrierStrategy) <span class="comment">//</span><b>(1)</b>
+==>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>(2)</b>
+==><span class="float">8295.525018999999</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>(3)</b>
+==><span class="float">24.969631</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>(4)</b>
+==><span class="float">19.926039</span>
+==><span class="integer">126653966</span></code></pre>
+</div>
+</div>
+<div class="colist arabic">
+<ol>
+<li>
+<p>Explicitly remove <code>LazyBarrierStrategy</code> which yields a bulking optimization.</p>
+</li>
+<li>
+<p>A non-bulking traversal where each traverser is processed.</p>
+</li>
+<li>
+<p>Each traverser entering <code>repeat()</code> has its recursion bulked.</p>
+</li>
+<li>
+<p>A bulking traversal where implicit traversers are not processed.</p>
+</li>
+</ol>
+</div>
+<div class="paragraph">
+<p>If <code>barrier()</code> is provided an integer argument, then the barrier will only hold <code>n</code>-number of unique traversers in its
+barrier before draining the aggregated traversers to the next step. This is useful in the aforementioned bulking
+optimization scenario with the added benefit of reducing the risk of an out-of-memory exception.</p>
+</div>
+<div class="paragraph">
+<p><code>LazyBarrierStrategy</code> inserts <code>barrier()</code>-steps into a traversal where appropriate in order to gain the
+"bulking optimization."</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<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>)
+gremlin> g = graph.traversal() <span class="comment">//</span><b>(1)</b>
+==>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">12.540834</span>
+==><span class="integer">126653966</span>
+gremlin> g.V().both().both().both().count().iterate().toString() <span class="comment">//</span><b>(2)</b>
+==>[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>
+</div>
+</div>
+<div class="colist arabic">
+<ol>
+<li>
+<p><code>LazyBarrierStrategy</code> is a default strategy and thus, does not need to be explicitly activated.</p>
+</li>
+<li>
+<p>With <code>LazyBarrierStrategy</code> activated, <code>barrier()</code> steps are automatically inserted where appropriate.</p>
+</li>
+</ol>
+</div>
+</div>
+<div class="sect2">
+<h3 id="by-step">By Step</h3>
+<div class="paragraph">
+<p>The <code>by()</code>-step is not an actual step, but instead is a "step-modulator" similar to <a href="#as-step"><code>as()</code></a> and
+<a href="#option-step"><code>option()</code></a>. If a step is able to accept traversals, functions, comparators, etc. then <code>by()</code> is the
+means by which they are added. The general pattern is <code>step().by()...by()</code>. Some steps can only accept one <code>by()</code>
+while others can take an arbitrary amount.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().group().by(bothE().count()) <span class="comment">//</span><b>(1)</b>
+==>[<span class="integer">1</span>:[v[<span class="integer">2</span>],v[<span class="integer">5</span>],v[<span class="integer">6</span>]],<span class="integer">3</span>:[v[<span class="integer">1</span>],v[<span class="integer">3</span>],v[<span class="integer">4</span>]]]
+gremlin> g.V().group().by(bothE().count()).by(<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">1</span>:[vadas,ripple,peter],<span class="integer">3</span>:[marko,lop,josh]]
+gremlin> g.V().group().by(bothE().count()).by(count()) <span class="comment">//</span><b>(3)</b>
+==>[<span class="integer">1</span>:<span class="integer">3</span>,<span class="integer">3</span>:<span class="integer">3</span>]</code></pre>
+</div>
+</div>
+<div class="colist arabic">
+<ol>
+<li>
+<p><code>by(outE().count())</code> will group the elements by their edge count (<strong>traversal</strong>).</p>
+</li>
+<li>
+<p><code>by('name')</code> will process the grouped elements by their name (<strong>element property projection</strong>).</p>
+</li>
+<li>
+<p><code>by(count())</code> will count the number of elements in each group (<strong>traversal</strong>).</p>
+</li>
+</ol>
+</div>
+</div>
+<div class="sect2">
+<h3 id="cap-step">Cap Step</h3>
+<div class="paragraph">
+<p>The <code>cap()</code>-step (<strong>barrier</strong>) iterates the traversal up to itself and emits the sideEffect referenced by the provided
+key. If multiple keys are provided, then a <code>Map<String,Object></code> of sideEffects is emitted.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().groupCount(<span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>).by(label).cap(<span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(1)</b>
+==>[<span class="key">software</span>:<span class="integer">2</span>,<span class="key">person</span>:<span class="integer">4</span>]
+gremlin> g.V().groupCount(<span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>).by(label).groupCount(<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>).by(outE().count()).cap(<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">b</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(2)</b>
+==>[<span class="key">a</span>:[<span class="key">software</span>:<span class="integer">2</span>,<span class="key">person</span>:<span class="integer">4</span>],<span class="key">b</span>:[<span class="integer">0</span>:<span class="integer">3</span>,<span class="integer">1</span>:<span class="integer">1</span>,<span class="integer">2</span>:<span class="integer">1</span>,<span class="integer">3</span>:<span class="integer">1</span>]]</code></pre>
+</div>
+</div>
+<div class="colist arabic">
+<ol>
+<li>
+<p>Group and count verticies by their label. Emit the side effect labeled <em>a</em>, which is the group count by label.</p>
+</li>
+<li>
+<p>Same as statement 1, but also emit the side effect labeled <em>b</em> which groups vertices by the number of out edges.</p>
+</li>
+</ol>
+</div>
+</div>
+<div class="sect2">
+<h3 id="choose-step">Choose Step</h3>
+<div class="imageblock">
+<div class="content">
+<img src="../images/choose-step.png" alt="choose step" width="700">
+</div>
+</div>
+<div class="paragraph">
+<p>The <code>choose()</code>-step (<strong>branch</strong>) routes the current traverser to a particular traversal branch option. With <code>choose()</code>,
+it is possible to implement if/then/else-semantics as well as more complicated selections.</p>
+</div>
+<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>).
choose(values(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>).is(lte(<span class="integer">30</span>)),
__.in(),
__.out()).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>
+==>marko
+==>ripple
+==>lop
+==>lop
gremlin> g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>).
choose(values(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>)).
option(<span class="integer">27</span>, __.in()).
option(<span class="integer">32</span>, __.out()).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>
==>marko
-==>marko
==>ripple
==>lop</code></pre>
</div>
@@ -4006,7 +4447,8 @@ gremlin> g.V().hasLabel(<span class="
<div class="listingblock">
<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">4</span>]
+==>v[<span class="integer">6</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>]
@@ -5564,15 +6006,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">6</span>]
==>v[<span class="integer">1</span>]
-==>v[<span class="integer">4</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>).order().by(shuffle)
-==>v[<span class="integer">2</span>]
+==>v[<span class="integer">1</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">2</span>]</code></pre>
</div>
</div>
<div class="paragraph">
@@ -5645,12 +6087,12 @@ 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.15000000000000002</span>
-==><span class="float">0.15000000000000002</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.4018125</span>
+==><span class="float">0.15000000000000002</span>
+==><span class="float">0.15000000000000002</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>)).
@@ -5902,19 +6344,19 @@ 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.077</span> <span class="float">8.48</span>
-VertexStep(OUT,[created],vertex) <span class="integer">4</span> <span class="integer">4</span> <span class="float">0.113</span> <span class="float">12.30</span>
-NoOpBarrierStep(<span class="integer">2500</span>) <span class="integer">4</span> <span class="integer">2</span> <span class="float">0.043</span> <span class="float">4.76</span>
-VertexStep(BOTH,vertex) <span class="integer">10</span> <span class="integer">4</span> <span class="float">0.033</span> <span class="float">3.66</span>
-NoOpBarrierStep(<span class="integer">2500</span>) <span class="integer">10</span> <span class="integer">3</span> <span class="float">0.027</span> <span class="float">2.99</span>
-VertexStep(BOTH,vertex) <span class="integer">24</span> <span class="integer">7</span> <span class="float">0.099</span> <span class="float">10.86</span>
-NoOpBarrierStep(<span class="integer">2500</span>) <span class="integer">24</span> <span class="integer">5</span> <span class="float">0.162</span> <span class="float">17.65</span>
-VertexStep(BOTH,vertex) <span class="integer">58</span> <span class="integer">11</span> <span class="float">0.096</span> <span class="float">10.53</span>
-NoOpBarrierStep(<span class="integer">2500</span>) <span class="integer">58</span> <span class="integer">6</span> <span class="float">0.055</span> <span class="float">6.03</span>
-HasStep([~label.eq(person)]) <span class="integer">48</span> <span class="integer">4</span> <span class="float">0.054</span> <span class="float">5.90</span>
-PropertiesStep([age],value) <span class="integer">48</span> <span class="integer">4</span> <span class="float">0.056</span> <span class="float">6.13</span>
-SumGlobalStep <span class="integer">1</span> <span class="integer">1</span> <span class="float">0.098</span> <span class="float">10.72</span>
- >TOTAL - - <span class="float">0.919</span> -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>) <span class="integer">6</span> <span class="integer">6</span> <span class="float">0.077</span> <span class="float">11.23</span>
+VertexStep(OUT,[created],vertex) <span class="integer">4</span> <span class="integer">4</span> <span class="float">0.097</span> <span class="float">14.17</span>
+NoOpBarrierStep(<span class="integer">2500</span>) <span class="integer">4</span> <span class="integer">2</span> <span class="float">0.043</span> <span class="float">6.29</span>
+VertexStep(BOTH,vertex) <span class="integer">10</span> <span class="integer">4</span> <span class="float">0.047</span> <span class="float">6.97</span>
+NoOpBarrierStep(<span class="integer">2500</span>) <span class="integer">10</span> <span class="integer">3</span> <span class="float">0.094</span> <span class="float">13.66</span>
+VertexStep(BOTH,vertex) <span class="integer">24</span> <span class="integer">7</span> <span class="float">0.029</span> <span class="float">4.32</span>
+NoOpBarrierStep(<span class="integer">2500</span>) <span class="integer">24</span> <span class="integer">5</span> <span class="float">0.031</span> <span class="float">4.65</span>
+VertexStep(BOTH,vertex) <span class="integer">58</span> <span class="integer">11</span> <span class="float">0.045</span> <span class="float">6.64</span>
+NoOpBarrierStep(<span class="integer">2500</span>) <span class="integer">58</span> <span class="integer">6</span> <span class="float">0.066</span> <span class="float">9.65</span>
+HasStep([~label.eq(person)]) <span class="integer">48</span> <span class="integer">4</span> <span class="float">0.032</span> <span class="float">4.67</span>
+PropertiesStep([age],value) <span class="integer">48</span> <span class="integer">4</span> <span class="float">0.038</span> <span class="float">5.54</span>
+SumGlobalStep <span class="integer">1</span> <span class="integer">1</span> <span class="float">0.084</span> <span class="float">12.22</span>
+ >TOTAL - - <span class="float">0.688</span> -</code></pre>
</div>
</div>
<div class="paragraph">
@@ -5962,10 +6404,10 @@ 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.063</span> -<span class="float">5131.34</span>
-VertexStep(OUT,[created],vertex) <span class="integer">4</span> <span class="integer">4</span> -<span class="float">0.096</span> <span class="float">7854.09</span>
-NoOpBarrierStep(<span class="integer">2500</span>) <span class="integer">4</span> <span class="integer">2</span> <span class="float">0.032</span> -<span class="float">2622.75</span>
- >TOTAL - - -<span class="float">0.001</span> -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>) <span class="integer">6</span> <span class="integer">6</span> <span class="float">0.075</span> <span class="float">182.75</span>
+VertexStep(OUT,[created],vertex) <span class="integer">4</span> <span class="integer">4</span> -<span class="float">0.135</span> -<span class="float">328.12</span>
+NoOpBarrierStep(<span class="integer">2500</span>) <span class="integer">4</span> <span class="integer">2</span> <span class="float">0.101</span> <span class="float">245.38</span>
+ >TOTAL - - <span class="float">0.041</span> -</code></pre>
</div>
</div>
<div class="paragraph">
@@ -6454,14 +6896,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">560e1459</span>
+==>java.util.Random<span class="error">@</span><span class="integer">340</span>ef431
gremlin> g.withSack {rand.nextFloat()}.V().sack()
-==><span class="float">0.28448385</span>
-==><span class="float">0.18038207</span>
-==><span class="float">0.4434358</span>
-==><span class="float">0.9477847</span>
-==><span class="float">0.10420513</span>
-==><span class="float">0.16689181</span></code></pre>
+==><span class="float">0.9838873</span>
+==><span class="float">0.12535542</span>
+==><span class="float">0.028003454</span>
+==><span class="float">0.011816442</span>
+==><span class="float">0.97978324</span>
+==><span class="float">0.15553969</span></code></pre>
</div>
</div>
<div class="paragraph">
@@ -6585,11 +7027,11 @@ gremlin></code></pre>
<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">0.4</span>
+==><span class="float">1.0</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>)
-==><span class="float">0.5</span>
+==><span class="float">1.0</span>
==><span class="float">1.0</span></code></pre>
</div>
</div>
@@ -6609,11 +7051,11 @@ the traverser never splits and continues
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">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">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>]]
+==>[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">9</span>][<span class="integer">1</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>]]
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">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">11</span>][<span class="integer">4</span>-created-><span class="integer">3</span>],v[<span class="integer">3</span>],e[<span class="integer">9</span>][<span class="integer">1</span>-created-><span class="integer">3</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">7</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>],v[<span class="integer">2</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">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">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">9</span>][<span class="integer">1</span>-created-><span class="integer">3</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">11</span>][<span class="integer">4</span>-created-><span class="integer">3</span>],v[<span class="integer">4</span>]]</code></pre>
</div>
</div>
</div>
@@ -7184,7 +7626,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">2.3405679999999998</span>
+==><span class="float">1.836264</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>
@@ -7193,7 +7635,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">1.5906369999999999</span></code></pre>
+==><span class="float">2.0008429999999997</span></code></pre>
</div>
</div>
<div class="paragraph">
@@ -9006,7 +9448,7 @@ memory manipulations).</p>
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> result = graph.compute().program(PageRankVertexProgram.build().create()).submit().get()
==>result[tinkergraph[<span class="key">vertices</span>:<span class="integer">6</span> <span class="key">edges</span>:<span class="integer">0</span>],memory[<span class="key">size</span>:<span class="integer">0</span>]]
gremlin> result.memory().runtime
-==><span class="integer">85</span>
+==><span class="integer">76</span>
gremlin> g = result.graph().traversal()
==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">6</span> <span class="key">edges</span>:<span class="integer">0</span>], standard]
gremlin> g.V().valueMap()
@@ -9373,7 +9815,7 @@ methods of a <code>VertexProgram</code>,
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> result = graph.compute().program(PageRankVertexProgram.build().create()).submit().get()
==>result[tinkergraph[<span class="key">vertices</span>:<span class="integer">6</span> <span class="key">edges</span>:<span class="integer">0</span>],memory[<span class="key">size</span>:<span class="integer">0</span>]]
gremlin> result.memory().runtime
-==><span class="integer">30</span>
+==><span class="integer">34</span>
gremlin> g = result.graph().traversal()
==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">6</span> <span class="key">edges</span>:<span class="integer">0</span>], standard]
gremlin> g.V().valueMap()
@@ -9393,9 +9835,9 @@ gremlin> g.V().valueMap()
<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().valueMap()
+==>[gremlin.pageRankVertexProgram.pageRank:[<span class="float">0.4018125</span>],<span class="key">name</span>:[lop],<span class="key">lang</span>:[java]]
==>[gremlin.pageRankVertexProgram.pageRank:[<span class="float">0.15000000000000002</span>],<span class="key">name</span>:[marko],<span class="key">age</span>:[<span class="integer">29</span>]]
==>[gremlin.pageRankVertexProgram.pageRank:[<span class="float">0.19250000000000003</span>],<span class="key">name</span>:[vadas],<span class="key">age</span>:[<span class="integer">27</span>]]
-==>[gremlin.pageRankVertexProgram.pageRank:[<span class="float">0.4018125</span>],<span class="key">name</span>:[lop],<span class="key">lang</span>:[java]]
==>[gremlin.pageRankVertexProgram.pageRank:[<span class="float">0.19250000000000003</span>],<span class="key">name</span>:[josh],<span class="key">age</span>:[<span class="integer">32</span>]]
==>[gremlin.pageRankVertexProgram.pageRank:[<span class="float">0.23181250000000003</span>],<span class="key">name</span>:[ripple],<span class="key">lang</span>:[java]]
==>[gremlin.pageRankVertexProgram.pageRank:[<span class="float">0.15000000000000002</span>],<span class="key">name</span>:[peter],<span class="key">age</span>:[<span class="integer">35</span>]]
@@ -9457,8 +9899,8 @@ gremlin> g.V().peerPressure().by(<spa
==>[<span class="key">cluster</span>:[<span class="integer">1</span>],<span class="key">name</span>:[ripple],<span class="key">lang</span>:[java]]
==>[<span class="key">cluster</span>:[<span class="integer">6</span>],<span class="key">name</span>:[peter],<span class="key">age</span>:[<span class="integer">35</span>]]
gremlin> g.V().peerPressure().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">cluster</span><span class="delimiter">'</span></span>).valueMap()
-==>[<span class="key">cluster</span>:[<span class="integer">1</span>],<span class="key">name</span>:[vadas],<span class="key">age</span>:[<span class="integer">27</span>]]
==>[<span class="key">cluster</span>:[<span class="integer">1</span>],<span class="key">name</span>:[marko],<span class="key">age</span>:[<span class="integer">29</span>]]
+==>[<span class="key">cluster</span>:[<span class="integer">1</span>],<span class="key">name</span>:[vadas],<span class="key">age</span>:[<span class="integer">27</span>]]
==>[<span class="key">cluster</span>:[<span class="integer">3</span>],<span class="key">name</span>:[lop],<span class="key">lang</span>:[java]]
==>[<span class="key">cluster</span>:[<span class="integer">1</span>],<span class="key">name</span>:[josh],<span class="key">age</span>:[<span class="integer">32</span>]]
==>[<span class="key">cluster</span>:[<span class="integer">5</span>],<span class="key">name</span>:[ripple],<span class="key">lang</span>:[java]]
@@ -9488,7 +9930,7 @@ from one TinkerGraph to another:</p>
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> writeGraphConf = <span class="keyword">new</span> BaseConfiguration()
-==>org.apache.commons.configuration.BaseConfiguration<span class="error">@</span><span class="integer">38811103</span>
+==>org.apache.commons.configuration.BaseConfiguration<span class="error">@</span><span class="integer">341</span>c6ac2
gremlin> writeGraphConf.setProperty(<span class="string"><span class="delimiter">"</span><span class="content">gremlin.graph</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph</span><span class="delimiter">"</span></span>)
gremlin> writeGraphConf.setProperty(<span class="string"><span class="delimiter">"</span><span class="content">gremlin.tinkergraph.graphFormat</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">gryo</span><span class="delimiter">"</span></span>)
gremlin> writeGraphConf.setProperty(<span class="string"><span class="delimiter">"</span><span class="content">gremlin.tinkergraph.graphLocation</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">/tmp/tinkergraph.kryo</span><span class="delimiter">"</span></span>)
@@ -9708,7 +10150,7 @@ gremlin> result.memory().a
gremlin> result.memory().iteration
==><span class="integer">1</span>
gremlin> result.memory().runtime
-==><span class="integer">13</span></code></pre>
+==><span class="integer">20</span></code></pre>
</div>
</div>
<div class="sect3">
@@ -10866,7 +11308,7 @@ for more information on that topic.</p>
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> :remote connect tinkerpop.server conf/remote.yaml session
-==>Configured localhost/<span class="float">127.0</span><span class="float">.0</span><span class="float">.1</span>:<span class="integer">8182</span>-[a018bdf1-<span class="float">5e44</span>-<span class="integer">4</span>ead-<span class="integer">8155</span>-<span class="float">578158477e70</span>]
+==>Configured localhost/<span class="float">127.0</span><span class="float">.0</span><span class="float">.1</span>:<span class="integer">8182</span>-[ec5732c8-ff7e-<span class="integer">4</span>a2b-be95-<span class="float">2e1</span>b9715fdfc]
gremlin> :> x = <span class="integer">1</span>
==><span class="integer">1</span>
gremlin> :> y = <span class="integer">2</span>
@@ -10893,9 +11335,9 @@ work with a remote connection to the ser
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="groovy language-groovy">gremlin> :remote connect tinkerpop.server conf/remote.yaml session
-==>Configured localhost/<span class="float">127.0</span><span class="float">.0</span><span class="float">.1</span>:<span class="integer">8182</span>-[c8117761-ced4-<span class="integer">4760</span>-<span class="float">8d</span>b1-<span class="float">3f</span>e91fc3ffd3]
+==>Configured localhost/<span class="float">127.0</span><span class="float">.0</span><span class="float">.1</span>:<span class="integer">8182</span>-[f7581ce9-f1a3-<span class="float">4d</span><span class="integer">50</span>-<span class="integer">8</span>c99-<span class="integer">171</span>c63d61595]
gremlin> :remote console
-==>All scripts will now be sent to Gremlin Server - [localhost/<span class="float">127.0</span><span class="float">.0</span><span class="float">.1</span>:<span class="integer">8182</span>]-[c8117761-ced4-<span class="integer">4760</span>-<span class="float">8d</span>b1-<span class="float">3f</span>e91fc3ffd3] - type <span class="string"><span class="delimiter">'</span><span class="content">:remote console</span><span class="delimiter">'</span></span> to <span class="keyword">return</span> to local mode
+==>All scripts will now be sent to Gremlin Server - [localhost/<span class="float">127.0</span><span class="float">.0</span><span class="float">.1</span>:<span class="integer">8182</span>]-[f7581ce9-f1a3-<span class="float">4d</span><span class="integer">50</span>-<span class="integer">8</span>c99-<span class="integer">171</span>c63d61595] - type <span class="string"><span class="delimiter">'</span><span class="content">:remote console</span><span class="delimiter">'</span></span> to <span class="keyword">return</span> to local mode
gremlin> x = <span class="integer">1</span>
==><span class="integer">1</span>
gremlin> y = <span class="integer">2</span>
@@ -10903,7 +11345,7 @@ gremlin> y = <span class="integer">2<
gremlin> x + y
==><span class="integer">3</span>
gremlin> :remote console
-==>All scripts will now be evaluated locally - type <span class="string"><span class="delimiter">'</span><span class="content">:remote console</span><span class="delimiter">'</span></span> to <span class="keyword">return</span> to remote mode <span class="keyword">for</span> Gremlin Server - [localhost/<span class="float">127.0</span><span class="float">.0</span><span class="float">.1</span>:<span class="integer">8182</span>]-[c8117761-ced4-<span class="integer">4760</span>-<span class="float">8d</span>b1-<span class="float">3f</span>e91fc3ffd3]</code></pre>
+==>All scripts will now be evaluated locally - type <span class="string"><span class="delimiter">'</span><span class="content">:remote console</span><span class="delimiter">'</span></span> to <span class="keyword">return</span> to remote mode <span class="keyword">for</span> Gremlin Server - [localhost/<span class="float">127.0</span><span class="float">.0</span><span class="float">.1</span>:<span class="integer">8182</span>]-[f7581ce9-f1a3-<span class="float">4d</span><span class="integer">50</span>-<span class="integer">8</span>c99-<span class="integer">171</span>c63d61595]</code></pre>
</div>
</div>
<div class="paragraph">
@@ -11608,13 +12050,13 @@ the <code>TraversalSource</code> be gene
gremlin> g = graph.traversal().withRemote(<span class="string"><span class="delimiter">'</span><span class="content">conf/remote-graph.properties</span><span class="delimiter">'</span></span>)
==>graphtraversalsource[emptygraph[empty], standard]
gremlin> g.V().valueMap(<span class="predefined-constant">true</span>)
-==>[<span class="key">label</span>:person,<span class="key">name</span>:[marko],<span class="key">age</span>:[<span class="integer">29</span>],<span class="key">id</span>:<span class="integer">1</span>]
-==>[<span class="key">label</span>:person,<span class="key">name</span>:[vadas],<span class="key">age</span>:[<span class="integer">27</span>],<span class="key">id</span>:<span class="integer">2</span>]
-==>[<span class="key">label</span>:software,<span class="key">name</span>:[lop],<span class="key">lang</span>:[java],<span class="key">id</span>:<span class="integer">3</span>]
-==>[<span class="key">label</span>:person,<span class="key">name</span>:[josh],<span class="key">age</span>:[<span class="integer">32</span>],<span class="key">id</span>:<span class="integer">4</span>]
-==>[<span class="key">label</span>:software,<span class="key">name</span>:[ripple],<span class="key">lang</span>:[java],<span class="key">id</span>:<span class="integer">5</span>]
-==>[<span class="key">label</span>:person,<span class="key">name</span>:[peter],<span class="key">age</span>:[<span class="integer">35</span>],<span class="key">id</span>:<span class="integer">6</span>]
-==>[<span class="key">label</span>:vertex,<span class="key">name</span>:[matthias],<span class="key">id</span>:<span class="integer">13</span>]
+==>[<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">age</span>:[<span class="integer">29</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">age</span>:[<span class="integer">27</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">lang</span>:[java]]
+==>[<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">age</span>:[<span class="integer">32</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">lang</span>:[java]]
+==>[<span class="key">name</span>:[peter],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">6</span>,<span class="key">age</span>:[<span class="integer">35</span>]]
+==>[<span class="key">name</span>:[matthias],<span class="key">label</span>:vertex,<span class="key">id</span>:<span class="integer">13</span>]
gremlin> g.close()</code></pre>
</div>
</div>
@@ -11636,13 +12078,13 @@ gremlin> graph = EmptyGraph.instance(
gremlin> g = graph.traversal().withRemote(DriverRemoteConnection.using(cluster, <span class="string"><span class="delimiter">"</span><span class="content">g</span><span class="delimiter">"</span></span>))
==>graphtraversalsource[emptygraph[empty], standard]
gremlin> g.V().valueMap(<span class="predefined-constant">true</span>)
-==>[<span class="key">label</span>:person,<span class="key">name</span>:[marko],<span class="key">age</span>:[<span class="integer">29</span>],<span class="key">id</span>:<span class="integer">1</span>]
-==>[<span class="key">label</span>:person,<span class="key">name</span>:[vadas],<span class="key">age</span>:[<span class="integer">27</span>],<span class="key">id</span>:<span class="integer">2</span>]
-==>[<span class="key">label</span>:software,<span class="key">name</span>:[lop],<span class="key">lang</span>:[java],<span class="key">id</span>:<span class="integer">3</span>]
-==>[<span class="key">label</span>:person,<span class="key">name</span>:[josh],<span class="key">age</span>:[<span class="integer">32</span>],<span class="key">id</span>:<span class="integer">4</span>]
-==>[<span class="key">label</span>:software,<span class="key">name</span>:[ripple],<span class="key">lang</span>:[java],<span class="key">id</span>:<span class="integer">5</span>]
-==>[<span class="key">label</span>:person,<span class="key">name</span>:[peter],<span class="key">age</span>:[<span class="integer">35</span>],<span class="key">id</span>:<span class="integer">6</span>]
-==>[<span class="key">label</span>:vertex,<span class="key">name</span>:[matthias],<span class="key">id</span>:<span class="integer">13</span>]
+==>[<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">age</span>:[<span class="integer">29</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">age</span>:[<span class="integer">27</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">lang</span>:[java]]
[... 472 lines stripped ...]