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/10/14 16:01:30 UTC
svn commit: r1764939 [2/4] - in /tinkerpop/site: docs/3.2.3-SNAPSHOT/images/
docs/3.2.3-SNAPSHOT/recipes/ docs/3.2.3-SNAPSHOT/reference/
docs/3.2.3-SNAPSHOT/upgrade/
javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/computer/
javadocs/3...
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=1764939&r1=1764938&r2=1764939&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html (original)
+++ tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html Fri Oct 14 16:01:29 2016
@@ -1125,6 +1125,7 @@ span.line-numbers { border-right: 1px so
<li><a href="#_bindings">Bindings</a></li>
<li><a href="#_traversal_strategies">Traversal Strategies</a></li>
<li><a href="#_the_lambda_solution">The Lambda Solution</a></li>
+<li><a href="#_custom_serialization">Custom Serialization</a></li>
</ul>
</li>
</ul>
@@ -4047,13 +4048,13 @@ gremlin> graph.io(graphml()).readGrap
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">8382.847754</span>
+==><span class="float">8263.601911</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">38.959904</span>
+==><span class="float">33.578151999999996</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">14.982242999999999</span>
+==><span class="float">17.57452</span>
==><span class="integer">126653966</span></code></pre>
</div>
</div>
@@ -4090,7 +4091,7 @@ gremlin> graph.io(graphml()).readGrap
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.814529</span>
+==><span class="float">7.922727999999999</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">10000</span>), VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">10000</span>), VertexStep(BOTH,edge), CountGlobalStep]</code></pre>
@@ -4314,9 +4315,9 @@ 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">2</span>]
==>v[<span class="integer">3</span>]
-==>v[<span class="integer">6</span>]
+==>v[<span class="integer">4</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>]
@@ -4435,12 +4436,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">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>:person]
-==>[<span class="key">id</span>:<span class="integer">3</span>,<span class="key">name</span>:[lop],<span class="key">label</span>:software]
-==>[<span class="key">id</span>:<span class="integer">4</span>,<span class="key">name</span>:[josh],<span class="key">label</span>:person]
-==>[<span class="key">id</span>:<span class="integer">5</span>,<span class="key">name</span>:[ripple],<span class="key">label</span>:software]
-==>[<span class="key">id</span>:<span class="integer">6</span>,<span class="key">name</span>:[peter],<span class="key">label</span>:person]
+==>[<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>
@@ -4521,12 +4522,12 @@ 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>))]
InlineFilterStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
MatchPredicateStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-FilterRankingStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
IncidentToAdjacentStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
AdjacentToIncidentStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+RepeatUnrollStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+FilterRankingStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
+PathRetractionStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
RangeByIsCountStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-RepeatUnrollStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
-PathRetractionStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
LazyBarrierStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
TinkerGraphStepStrategy [P] [TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
ProfileStrategy [F] [TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, IsStep(gt(<span class="integer">5</span>))]
@@ -5653,14 +5654,14 @@ gremlin> g.V().hasLabel(<span class="
<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>]
-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">1</span>]
-==>v[<span class="integer">2</span>]
==>v[<span class="integer">6</span>]
-==>v[<span class="integer">4</span>]</code></pre>
+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>]</code></pre>
</div>
</div>
<div class="paragraph">
@@ -5733,12 +5734,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.19250000000000003</span>
+==><span class="float">0.19250000000000003</span>
==><span class="float">0.4018125</span>
==><span class="float">0.23181250000000003</span>
==><span class="float">0.15000000000000002</span>
==><span class="float">0.15000000000000002</span>
-==><span class="float">0.19250000000000003</span>
-==><span class="float">0.19250000000000003</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>)).
@@ -5775,23 +5776,23 @@ InlineFilterStrategy [O] [Trav
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]
-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
+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]
IncidentToAdjacentStrategy [O] [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
AdjacentToIncidentStrategy [O] [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
-RangeByIsCountStrategy [O] [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
- ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
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]
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]
-LazyBarrierStrategy [O] [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
+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]
-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
+LazyBarrierStrategy [O] [TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)])],graphfilter[none]), PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span class="integer">30</span>,graphfilter[none]), TraversalV
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), PropertyMapStep([name, friendRank],value)],graphfilter[none]), ComputerResultStep]
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]
@@ -5955,7 +5956,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>
@@ -5984,18 +5985,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.086</span> <span class="float">12.77</span>
-VertexStep(OUT,[created],vertex) <span class="integer">4</span> <span class="integer">4</span> <span class="float">0.110</span> <span class="float">16.20</span>
-VertexStep(BOTH,vertex) <span class="integer">10</span> <span class="integer">10</span> <span class="float">0.132</span> <span class="float">19.50</span>
-NoOpBarrierStep(<span class="integer">5000</span>) <span class="integer">10</span> <span class="integer">3</span> <span class="float">0.062</span> <span class="float">9.19</span>
-VertexStep(BOTH,vertex) <span class="integer">24</span> <span class="integer">7</span> <span class="float">0.030</span> <span class="float">4.48</span>
-NoOpBarrierStep(<span class="integer">5000</span>) <span class="integer">24</span> <span class="integer">5</span> <span class="float">0.029</span> <span class="float">4.33</span>
-VertexStep(BOTH,vertex) <span class="integer">58</span> <span class="integer">11</span> <span class="float">0.037</span> <span class="float">5.55</span>
-NoOpBarrierStep(<span class="integer">5000</span>) <span class="integer">58</span> <span class="integer">6</span> <span class="float">0.045</span> <span class="float">6.65</span>
-HasStep([~label.eq(person)]) <span class="integer">48</span> <span class="integer">4</span> <span class="float">0.029</span> <span class="float">4.30</span>
-PropertiesStep([age],value) <span class="integer">48</span> <span class="integer">4</span> <span class="float">0.034</span> <span class="float">5.04</span>
-SumGlobalStep <span class="integer">1</span> <span class="integer">1</span> <span class="float">0.081</span> <span class="float">11.99</span>
- >TOTAL - - <span class="float">0.681</span> -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>) <span class="integer">6</span> <span class="integer">6</span> <span class="float">0.072</span> <span class="float">12.13</span>
+VertexStep(OUT,[created],vertex) <span class="integer">4</span> <span class="integer">4</span> <span class="float">0.101</span> <span class="float">17.04</span>
+VertexStep(BOTH,vertex) <span class="integer">10</span> <span class="integer">10</span> <span class="float">0.063</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.057</span> <span class="float">9.57</span>
+VertexStep(BOTH,vertex) <span class="integer">24</span> <span class="integer">7</span> <span class="float">0.030</span> <span class="float">5.04</span>
+NoOpBarrierStep(<span class="integer">5000</span>) <span class="integer">24</span> <span class="integer">5</span> <span class="float">0.028</span> <span class="float">4.82</span>
+VertexStep(BOTH,vertex) <span class="integer">58</span> <span class="integer">11</span> <span class="float">0.040</span> <span class="float">6.75</span>
+NoOpBarrierStep(<span class="integer">5000</span>) <span class="integer">58</span> <span class="integer">6</span> <span class="float">0.057</span> <span class="float">9.60</span>
+HasStep([~label.eq(person)]) <span class="integer">48</span> <span class="integer">4</span> <span class="float">0.029</span> <span class="float">4.98</span>
+PropertiesStep([age],value) <span class="integer">48</span> <span class="integer">4</span> <span class="float">0.034</span> <span class="float">5.84</span>
+SumGlobalStep <span class="integer">1</span> <span class="integer">1</span> <span class="float">0.080</span> <span class="float">13.51</span>
+ >TOTAL - - <span class="float">0.596</span> -</code></pre>
</div>
</div>
<div class="paragraph">
@@ -6043,9 +6044,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.100</span> -<span class="float">115.95</span>
-VertexStep(OUT,[created],vertex) <span class="integer">4</span> <span class="integer">4</span> -<span class="float">0.186</span> <span class="float">215.95</span>
- >TOTAL - - -<span class="float">0.086</span> -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>) <span class="integer">6</span> <span class="integer">6</span> <span class="float">0.144</span> -<span class="float">90.76</span>
+VertexStep(OUT,[created],vertex) <span class="integer">4</span> <span class="integer">4</span> -<span class="float">0.303</span> <span class="float">190.76</span>
+ >TOTAL - - -<span class="float">0.159</span> -</code></pre>
</div>
</div>
<div class="paragraph">
@@ -6199,8 +6200,8 @@ gremlin> g.V().hasLabel(<span class="
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>:[josh],<span class="key">rank</span>:[<span class="float">0.19250000000000003</span>]]
-==>[<span class="key">name</span>:[vadas],<span class="key">rank</span>:[<span class="float">0.19250000000000003</span>]]</code></pre>
+==>[<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>
</div>
</div>
@@ -6466,14 +6467,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">2f</span><span class="integer">98859</span>a
+==>java.util.Random<span class="error">@</span><span class="float">6e95</span>c023
gremlin> g.withSack {rand.nextFloat()}.V().sack()
-==><span class="float">0.5964332</span>
-==><span class="float">0.88723356</span>
-==><span class="float">0.4387771</span>
-==><span class="float">0.82640034</span>
-==><span class="float">0.62456286</span>
-==><span class="float">0.5871389</span></code></pre>
+==><span class="float">0.98372227</span>
+==><span class="float">0.25891244</span>
+==><span class="float">0.84362406</span>
+==><span class="float">0.9044096</span>
+==><span class="float">0.9889438</span>
+==><span class="float">0.54450595</span></code></pre>
</div>
</div>
<div class="paragraph">
@@ -6586,10 +6587,10 @@ gremlin> g.withBulk(<span class="pred
<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.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">0.4</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">1.0</span>
-==><span class="float">1.0</span></code></pre>
+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">0.4</span></code></pre>
</div>
</div>
<div class="paragraph">
@@ -6604,15 +6605,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">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">5</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">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>],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>]]
+==>[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">9</span>][<span class="integer">1</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">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">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">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">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>]]</code></pre>
+==>[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">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">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">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>]]</code></pre>
</div>
</div>
</div>
@@ -7121,7 +7122,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">1.890463</span>
+==><span class="float">1.703647</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>
@@ -7130,7 +7131,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">2.36301</span></code></pre>
+==><span class="float">1.461136</span></code></pre>
</div>
</div>
<div class="paragraph">
@@ -7328,30 +7329,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">id</span>:<span class="integer">1</span>,<span class="key">name</span>:[marko],<span class="key">label</span>:person,<span class="key">location</span>:[san diego,santa cruz,brussels,santa fe]]
-==>[<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">location</span>:[centreville,dulles,purcellville]]
-==>[<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">location</span>:[bremen,baltimore,oakland,seattle]]
-==>[<span class="key">id</span>:<span class="integer">9</span>,<span class="key">name</span>:[daniel],<span class="key">label</span>:person,<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">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">label</span>:person]
+==>[<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">key</span>:location,<span class="key">startTime</span>:<span class="integer">1997</span>,<span class="key">endTime</span>:<span class="integer">2001</span>,<span class="key">value</span>:san diego]
-==>[<span class="key">id</span>:<span class="integer">7</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2001</span>,<span class="key">endTime</span>:<span class="integer">2004</span>,<span class="key">value</span>:santa cruz]
-==>[<span class="key">id</span>:<span class="integer">8</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2004</span>,<span class="key">endTime</span>:<span class="integer">2005</span>,<span class="key">value</span>:brussels]
-==>[<span class="key">id</span>:<span class="integer">9</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2005</span>,<span class="key">value</span>:santa fe]
-==>[<span class="key">id</span>:<span class="integer">10</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">1990</span>,<span class="key">endTime</span>:<span class="integer">2000</span>,<span class="key">value</span>:centreville]
-==>[<span class="key">id</span>:<span class="integer">11</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2000</span>,<span class="key">endTime</span>:<span class="integer">2006</span>,<span class="key">value</span>:dulles]
-==>[<span class="key">id</span>:<span class="integer">12</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2006</span>,<span class="key">value</span>:purcellville]
-==>[<span class="key">id</span>:<span class="integer">13</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2004</span>,<span class="key">endTime</span>:<span class="integer">2007</span>,<span class="key">value</span>:bremen]
-==>[<span class="key">id</span>:<span class="integer">14</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2007</span>,<span class="key">endTime</span>:<span class="integer">2011</span>,<span class="key">value</span>:baltimore]
-==>[<span class="key">id</span>:<span class="integer">15</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2011</span>,<span class="key">endTime</span>:<span class="integer">2014</span>,<span class="key">value</span>:oakland]
-==>[<span class="key">id</span>:<span class="integer">16</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2014</span>,<span class="key">value</span>:seattle]
-==>[<span class="key">id</span>:<span class="integer">17</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">1982</span>,<span class="key">endTime</span>:<span class="integer">2005</span>,<span class="key">value</span>:spremberg]
-==>[<span class="key">id</span>:<span class="integer">18</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2005</span>,<span class="key">endTime</span>:<span class="integer">2009</span>,<span class="key">value</span>:kaiserslautern]
-==>[<span class="key">id</span>:<span class="integer">19</span>,<span class="key">key</span>:location,<span class="key">startTime</span>:<span class="integer">2009</span>,<span class="key">value</span>:aachen]</code></pre>
+==>[<span class="key">startTime</span>:<span class="integer">1997</span>,<span class="key">endTime</span>:<span class="integer">2001</span>,<span class="key">value</span>:san diego,<span class="key">id</span>:<span class="integer">6</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2001</span>,<span class="key">endTime</span>:<span class="integer">2004</span>,<span class="key">value</span>:santa cruz,<span class="key">id</span>:<span class="integer">7</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2004</span>,<span class="key">endTime</span>:<span class="integer">2005</span>,<span class="key">value</span>:brussels,<span class="key">id</span>:<span class="integer">8</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2005</span>,<span class="key">value</span>:santa fe,<span class="key">id</span>:<span class="integer">9</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">1990</span>,<span class="key">endTime</span>:<span class="integer">2000</span>,<span class="key">value</span>:centreville,<span class="key">id</span>:<span class="integer">10</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2000</span>,<span class="key">endTime</span>:<span class="integer">2006</span>,<span class="key">value</span>:dulles,<span class="key">id</span>:<span class="integer">11</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2006</span>,<span class="key">value</span>:purcellville,<span class="key">id</span>:<span class="integer">12</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2004</span>,<span class="key">endTime</span>:<span class="integer">2007</span>,<span class="key">value</span>:bremen,<span class="key">id</span>:<span class="integer">13</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2007</span>,<span class="key">endTime</span>:<span class="integer">2011</span>,<span class="key">value</span>:baltimore,<span class="key">id</span>:<span class="integer">14</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2011</span>,<span class="key">endTime</span>:<span class="integer">2014</span>,<span class="key">value</span>:oakland,<span class="key">id</span>:<span class="integer">15</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2014</span>,<span class="key">value</span>:seattle,<span class="key">id</span>:<span class="integer">16</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">1982</span>,<span class="key">endTime</span>:<span class="integer">2005</span>,<span class="key">value</span>:spremberg,<span class="key">id</span>:<span class="integer">17</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2005</span>,<span class="key">endTime</span>:<span class="integer">2009</span>,<span class="key">value</span>:kaiserslautern,<span class="key">id</span>:<span class="integer">18</span>,<span class="key">key</span>:location]
+==>[<span class="key">startTime</span>:<span class="integer">2009</span>,<span class="key">value</span>:aachen,<span class="key">id</span>:<span class="integer">19</span>,<span class="key">key</span>:location]</code></pre>
</div>
</div>
</div>
@@ -7967,13 +7968,15 @@ depending on whether there is or is not
<span class="directive">final</span> TinkerGraphStep<?, ?> tinkerGraphStep = <span class="keyword">new</span> TinkerGraphStep<>(originalGraphStep);
TraversalHelper.replaceStep(originalGraphStep, tinkerGraphStep, traversal);
Step<?, ?> currentStep = tinkerGraphStep.getNextStep();
- <span class="keyword">while</span> (currentStep <span class="keyword">instanceof</span> HasStep) {
- <span class="keyword">for</span> (<span class="directive">final</span> HasContainer hasContainer : ((HasContainerHolder) currentStep).getHasContainers()) {
- <span class="keyword">if</span> (!GraphStep.processHasContainerIds(tinkerGraphStep, hasContainer))
- tinkerGraphStep.addHasContainer(hasContainer);
+ <span class="keyword">while</span> (currentStep <span class="keyword">instanceof</span> HasStep || currentStep <span class="keyword">instanceof</span> NoOpBarrierStep) {
+ <span class="keyword">if</span> (currentStep <span class="keyword">instanceof</span> HasStep) {
+ <span class="keyword">for</span> (<span class="directive">final</span> HasContainer hasContainer : ((HasContainerHolder) currentStep).getHasContainers()) {
+ <span class="keyword">if</span> (!GraphStep.processHasContainerIds(tinkerGraphStep, hasContainer))
+ tinkerGraphStep.addHasContainer(hasContainer);
+ }
+ TraversalHelper.copyLabels(currentStep, currentStep.getPreviousStep(), <span class="predefined-constant">false</span>);
+ traversal.removeStep(currentStep);
}
- TraversalHelper.copyLabels(currentStep, tinkerGraphStep, <span class="predefined-constant">false</span>);
- traversal.removeStep(currentStep);
currentStep = currentStep.getNextStep();
}
}
@@ -7987,11 +7990,9 @@ depending on whether there is or is not
</div>
<div class="paragraph">
<p>The traversal is redefined by simply taking a chain of <code>has()</code>-steps after <code>g.V()</code> (<code>TinkerGraphStep</code>) and providing
-their <code>HasContainers</code> to <code>TinkerGraphStep</code>. Then its up to <code>TinkerGraphStep</code> to determine if an appropriate index exists. In the code
-below, review the <code>vertices()</code> method and note how if an index exists, for a particular <code>HasContainer</code>, then that
-index is first queried before the remaining <code>HasContainer</code> filters are serially applied. Given that the strategy
-uses non-TinkerPop3 provided steps, it should go into the <code>ProviderOptimizationStrategy</code> category to ensure the
-added step does not interfere with the assumptions of the <code>OptimizationStrategy</code> strategies.</p>
+their <code>HasContainers</code> to <code>TinkerGraphStep</code>. Then its up to <code>TinkerGraphStep</code> to determine if an appropriate index exists.
+Given that the strategy uses non-TinkerPop3 provided steps, it should go into the <code>ProviderOptimizationStrategy</code> category
+to ensure the added step does not interfere with the assumptions of the <code>OptimizationStrategy</code> strategies.</p>
</div>
<div class="listingblock">
<div class="content">
@@ -8056,23 +8057,23 @@ InlineFilterStrategy [O] [Grap
MatchPredicateStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],value)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Repeat
Step([VertexStep(OUT,edge), EdgeVertexStep(IN), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTra
versalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-FilterRankingStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)]), TraversalFilterStep([PropertiesStep([name],value)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Repeat
- Step([VertexStep(OUT,edge), EdgeVertexStep(IN), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTra
- versalStep([WhereStartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-IncidentToAdjacentStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)]), TraversalFilterStep([PropertiesStep([name],value)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Repeat
+IncidentToAdjacentStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],value)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Repeat
Step([VertexStep(OUT,vertex), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([WhereS
tartStep, VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-AdjacentToIncidentStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)]), TraversalFilterStep([PropertiesStep([name],property)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Rep
+AdjacentToIncidentStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],property)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Rep
eatStep([VertexStep(OUT,vertex), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([Whe
reStartStep, VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
-RangeByIsCountStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)]), TraversalFilterStep([PropertiesStep([name],property)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Rep
- eatStep([VertexStep(OUT,vertex), RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span class="predefined-constant">false</span>)), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTraversalStep([Whe
- reStartStep, VertexStep(BOTH,edge), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">2</span>), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
-RepeatUnrollStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)]), TraversalFilterStep([PropertiesStep([name],property)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
+RepeatUnrollStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), TraversalFilterStep([PropertiesStep([name],property)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
texStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTrave
- rsalStep([WhereStartStep, VertexStep(BOTH,edge), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">2</span>), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+ rsalStep([WhereStartStep, VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+FilterRankingStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)]), TraversalFilterStep([PropertiesStep([name],property)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
+ texStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTrave
+ rsalStep([WhereStartStep, VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
PathRetractionStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)]), TraversalFilterStep([PropertiesStep([name],property)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
texStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTrave
+ rsalStep([WhereStartStep, VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+RangeByIsCountStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)]), TraversalFilterStep([PropertiesStep([name],property)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
+ texStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTrave
rsalStep([WhereStartStep, VertexStep(BOTH,edge), RangeGlobalStep(<span class="integer">0</span>,<span class="integer">2</span>), CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
LazyBarrierStrategy [O] [GraphStep(vertex,<span class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span class="integer">32</span>)]), TraversalFilterStep([PropertiesStep([name],property)])<span class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
texStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], [MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], [MatchStartStep(b), WhereTrave
@@ -8382,12 +8383,12 @@ SubgraphStrategy [D] [Grap
ConnectiveStrategy [D] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), TraversalFilterStep([NotStep([PropertiesStep([endTime],value)])]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
InlineFilterStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],value)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
MatchPredicateStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],value)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
-FilterRankingStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],value)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
IncidentToAdjacentStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],value)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
AdjacentToIncidentStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
-RangeByIsCountStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
RepeatUnrollStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
+FilterRankingStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
PathRetractionStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity]), NoOpBarrierStep(<span class="integer">2500</span>)]
+RangeByIsCountStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity]), NoOpBarrierStep(<span class="integer">2500</span>)]
LazyBarrierStrategy [O] [GraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity]), NoOpBarrierStep(<span class="integer">2500</span>)]
TinkerGraphStepStrategy [P] [TinkerGraphStep(vertex,<span class="type">[]</span>)<span class="error">@</span>[a], PropertiesStep([location],property), NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span class="error">@</span>[b], SelectStep([a, b],[value(name), identity]), NoOpBarrierStep(<span class="integer">25</span>
<span class="octal">00</span>)]
@@ -8440,14 +8441,14 @@ gremlin> g = graph.traversal().withSt
vertexProperties(or(hasLabel(neq(<span class="string"><span class="delimiter">'</span><span class="content">location</span><span class="delimiter">'</span></span>)),hasNot(<span class="string"><span class="delimiter">'</span><span class="content">endTime</span><span class="delimiter">'</span></span>))).create())
==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">6</span> <span class="key">edges</span>:<span class="integer">14</span>], standard]
gremlin> g.V().valueMap(<span class="predefined-constant">true</span>)
-==>[<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">location</span>:[santa fe]]
-==>[<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">location</span>:[seattle]]
-==>[<span class="key">id</span>:<span class="integer">10</span>,<span class="key">name</span>:[gremlin],<span class="key">label</span>:software]
-==>[<span class="key">id</span>:<span class="integer">11</span>,<span class="key">name</span>:[tinkergraph],<span class="key">label</span>:software]
+==>[<span class="key">name</span>:[marko],<span class="key">location</span>:[santa fe],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">1</span>]
+==>[<span class="key">name</span>:[matthias],<span class="key">location</span>:[seattle],<span class="key">label</span>:person,<span class="key">id</span>:<span class="integer">8</span>]
+==>[<span class="key">name</span>:[gremlin],<span class="key">label</span>:software,<span class="key">id</span>:<span class="integer">10</span>]
+==>[<span class="key">name</span>:[tinkergraph],<span class="key">label</span>:software,<span class="key">id</span>:<span class="integer">11</span>]
gremlin> g.E().valueMap(<span class="predefined-constant">true</span>)
-==>[<span class="key">id</span>:<span class="integer">13</span>,<span class="key">label</span>:develops,<span class="key">since</span>:<span class="integer">2009</span>]
-==>[<span class="key">id</span>:<span class="integer">14</span>,<span class="key">label</span>:develops,<span class="key">since</span>:<span class="integer">2010</span>]
-==>[<span class="key">id</span>:<span class="integer">21</span>,<span class="key">label</span>:develops,<span class="key">since</span>:<span class="integer">2012</span>]
+==>[<span class="key">label</span>:develops,<span class="key">id</span>:<span class="integer">13</span>,<span class="key">since</span>:<span class="integer">2009</span>]
+==>[<span class="key">label</span>:develops,<span class="key">id</span>:<span class="integer">14</span>,<span class="key">since</span>:<span class="integer">2010</span>]
+==>[<span class="key">label</span>:develops,<span class="key">id</span>:<span class="integer">21</span>,<span class="key">since</span>:<span class="integer">2012</span>]
gremlin> g.V().outE().inV().
path().
by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>).
@@ -15857,7 +15858,7 @@ it is possible to use the <code>withBind
<h3 id="_traversal_strategies">Traversal Strategies</h3>
<div class="paragraph">
<p>In order to add and remove <a href="#traversalstrategy">traversal strategies</a> from a traversal source, Gremlin-Python has a
-<code>TraversalStrategy</code> class along with numerous subclasses that mirror the standard, distributed strategies.</p>
+<code>TraversalStrategy</code> class along with a collection of subclasses that mirror the standard Gremlin-Java strategies.</p>
</div>
<div class="listingblock">
<div class="content">
@@ -15888,7 +15889,7 @@ null
<div class="title">Note</div>
</td>
<td class="content">
-Many of the <code>TraversalStrategy</code> classes in Gremlin-Python are proxies to the respective strategy on the
+Many of the <code>TraversalStrategy</code> classes in Gremlin-Python are proxies to the respective strategy on
Apache TinkerPop’s JVM-based Gremlin traversal machine. As such, their <code>apply(Traversal)</code> method does nothing. However,
the strategy is encoded in the Gremlin-Python bytecode and transmitted to the Gremlin traversal machine for
re-construction machine-side.
@@ -15956,6 +15957,43 @@ null
</ol>
</div>
</div>
+<div class="sect2">
+<h3 id="_custom_serialization">Custom Serialization</h3>
+<div class="paragraph">
+<p>Gremlin-Python provides a GraphSON 2.0 serialization package with the standard Apache TinkerPop <code>g</code>-types registered
+(see <a href="http://tinkerpop.apache.org/docs/3.2.3-SNAPSHOT/dev/io/#graphson-2d0">GraphSON 2.0</a>). It is possible for users to add
+new types by creating serializers and deserializers in Python and registering them with the <code>RemoteConnection</code>.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="python language-python"><span class="keyword">class</span> <span class="class">MyType</span>(<span class="predefined">object</span>):
+ GRAPHSON_PREFIX = <span class="string"><span class="delimiter">"</span><span class="content">providerx</span><span class="delimiter">"</span></span>
+ GRAPHSON_BASE_TYPE = <span class="string"><span class="delimiter">"</span><span class="content">MyType</span><span class="delimiter">"</span></span>
+ GRAPHSON_TYPE = GraphSONUtil.formatType(GRAPHSON_PREFIX, GRAPHSON_BASE_TYPE)
+
+ <span class="keyword">def</span> <span class="function">__init__</span>(<span class="predefined-constant">self</span>, x, y):
+ <span class="predefined-constant">self</span>.x = x
+ <span class="predefined-constant">self</span>.y = y
+
+ <span class="decorator">@classmethod</span>
+ <span class="keyword">def</span> <span class="function">objectify</span>(cls, value, reader):
+ <span class="keyword">return</span> cls(value[<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>], value[<span class="string"><span class="delimiter">'</span><span class="content">y</span><span class="delimiter">'</span></span>])
+
+ <span class="decorator">@classmethod</span>
+ <span class="keyword">def</span> <span class="function">dictify</span>(cls, value, writer):
+ <span class="keyword">return</span> GraphSONUtil.typedValue(cls.GRAPHSON_BASE_TYPE,
+ {<span class="string"><span class="delimiter">'</span><span class="content">x</span><span class="delimiter">'</span></span>: value.x, <span class="string"><span class="delimiter">'</span><span class="content">y</span><span class="delimiter">'</span></span>: value.y},
+ cls.GRAPHSON_PREFIX)
+
+graphson_reader = GraphSONReader({MyType.GRAPHSON_TYPE: MyType})
+graphson_writer = GraphSONWriter({MyType: MyType})
+
+connection = DriverRemoteConnection(<span class="string"><span class="delimiter">'</span><span class="content">ws://localhost:8182/gremlin</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">g</span><span class="delimiter">'</span></span>,
+ graphson_reader=graphson_reader,
+ graphson_writer=graphson_writer)</code></pre>
+</div>
+</div>
+</div>
</div>
</div>
<h1 id="conclusion" class="sect0">Conclusion</h1>
@@ -15986,7 +16024,7 @@ cheerfully greet visitors to the TinkerP
</div>
<div id="footer">
<div id="footer-text">
-Last updated 2016-10-13 11:25:26 -04:00
+Last updated 2016-10-14 11:58:59 -04:00
</div>
</div>
</body>
Modified: tinkerpop/site/docs/3.2.3-SNAPSHOT/upgrade/index.html
URL: http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.3-SNAPSHOT/upgrade/index.html?rev=1764939&r1=1764938&r2=1764939&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.3-SNAPSHOT/upgrade/index.html (original)
+++ tinkerpop/site/docs/3.2.3-SNAPSHOT/upgrade/index.html Fri Oct 14 16:01:29 2016
@@ -1043,14 +1043,39 @@ formats: GraphML, GraphSON and Gryo.</p>
<div class="sect3">
<h4 id="_graph_system_providers">Graph System Providers</h4>
<div class="sect4">
-<h5 id="_configurable_strategies">Configurable Strategies</h5>
+<h5 id="_default_lazybarrierstrategy">Default LazyBarrierStrategy</h5>
+<div class="paragraph">
+<p><code>LazyBarrierStrategy</code> has been included as a default strategy. <code>LazyBarrierStrategy</code> walks a traversal and looks for
+"flatMaps" (<code>out()</code>, <code>in()</code>, <code>both()</code>, <code>values()</code>, <code>V()</code>, etc.) and adds "lazy barriers" to dam up the stream so to
+increase the probability of bulking the traversers. One of the side-effects is that:</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="java language-java">g.V().out().V().has(a)</code></pre>
+</div>
+</div>
+<div class="paragraph">
+<p>is compiled to:</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="java language-java">g.V().out().barrier().V().barrier().has(a)</code></pre>
+</div>
+</div>
<div class="paragraph">
-<p><code>TraversalSource.withStrategies()</code> and <code>TraversalSource.withoutStrategies()</code> use Java objects. In order to make strategy
-manipulation possible from Gremlin language variants like Gremlin-Python, it is important to support non-JVM-based versions
-of these methods. As such, <code>TraversalSource.withStrategies(Map<String,Object>...)</code> and <code>TraversalSource.withoutStrategies(String...)</code>
-were added.</p>
+<p>Given that <code>LazyBarrierStrategy</code> is an <code>OptimizationStrategy</code>, it comes before <code>ProviderOptimizationStrategies</code>.
+Thus, if the provider’s <code>XXXGraphStepStrategy</code> simply walks from the second <code>V()</code> looking for <code>has()</code>-only, it will not
+be able to pull in the <code>has()</code> cause the <code>barrier()</code> blocks it. Please see the updates to <code>TinkerGraphStepStrategy</code> and
+how it acknowledges <code>NoOpBarrierSteps</code> (i.e. <code>barrier()`</code>) skipping over them and “left”-propagating labels to the
+previous step.</p>
</div>
<div class="paragraph">
+<p>See: <a href="https://issues.apache.org/jira/browse/TINKERPOP-1488">TINKERPOP-1488</a></p>
+</div>
+</div>
+<div class="sect4">
+<h5 id="_configurable_strategies">Configurable Strategies</h5>
+<div class="paragraph">
<p>If the provider has non-configurable <code>TraversalStrategy</code> classes, those classes should expose a static <code>instance()</code>-method.
This is typical and thus, backwards compatible. However, if the provider has a <code>TraversalStrategy</code> that can be configured
(e.g. via a <code>Builder</code>), then it should expose a static <code>create(Configuration)</code>-method, where the keys of the configuration
@@ -1060,9 +1085,7 @@ a <code>SubgraphStrategy</code>, it does
<div class="listingblock">
<div class="content">
<pre class="CodeRay"><code class="python language-python">g = Graph().traversal().withRemote(connection).
- withStrategy({<span class="string"><span class="delimiter">'</span><span class="content">strategy</span><span class="delimiter">'</span></span>:<span class="string"><span class="delimiter">'</span><span class="content">org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategy</span><span class="delimiter">'</span></span>,
- <span class="string"><span class="delimiter">'</span><span class="content">vertices</span><span class="delimiter">'</span></span>: __.hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>),
- <span class="string"><span class="delimiter">'</span><span class="content">edges</span><span class="delimiter">'</span></span>: __.has(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>,gt(<span class="float">0.5</span>))})
+ withStrategies(SubgraphStrategy(vertices=__.hasLabel(<span class="string"><span class="delimiter">'</span><span class="content">person</span><span class="delimiter">'</span></span>),edges=__.has(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>,gt(<span class="float">0.5</span>))))
---
The `SubgraphStrategy.create(Configuration)`-method <span class="keyword">is</span> defined <span class="keyword">as</span>:
@@ -1118,7 +1141,7 @@ The default implementation of `Traversal
</div>
<div class="paragraph">
<p>public default Configuration getConfiguration() {
- return new MapConfiguration(Collections.singletonMap(STRATEGY, this.getClass().getCanonicalName()));
+ return new BaseConfiguration();
}</p>
</div>
<div class="listingblock">
@@ -2900,7 +2923,7 @@ See: link:http://tinkerpop.apache.org/do
</div>
<div id="footer">
<div id="footer-text">
-Last updated 2016-10-12 14:45:07 -04:00
+Last updated 2016-10-14 11:59:00 -04:00
</div>
</div>
</body>
Modified: tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/computer/package-tree.html
URL: http://svn.apache.org/viewvc/tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/computer/package-tree.html?rev=1764939&r1=1764938&r2=1764939&view=diff
==============================================================================
--- tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/computer/package-tree.html (original)
+++ tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/computer/package-tree.html Fri Oct 14 16:01:29 2016
@@ -2,10 +2,10 @@
<!-- NewPage -->
<html lang="en">
<head>
-<!-- Generated by javadoc (1.8.0_101) on Wed Oct 12 14:46:14 EDT 2016 -->
+<!-- Generated by javadoc (1.8.0_101) on Fri Oct 14 12:00:08 EDT 2016 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>org.apache.tinkerpop.gremlin.process.computer Class Hierarchy (Apache TinkerPop 3.2.3-SNAPSHOT API)</title>
-<meta name="date" content="2016-10-12">
+<meta name="date" content="2016-10-14">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../../script.js"></script>
</head>
@@ -137,11 +137,11 @@
<ul>
<li type="circle">java.lang.<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Enum.html?is-external=true" title="class or interface in java.lang"><span class="typeNameLink">Enum</span></a><E> (implements java.lang.<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html?is-external=true" title="class or interface in java.lang">Comparable</a><T>, java.io.<a href="http://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html?is-external=true" title="class or interface in java.io">Serializable</a>)
<ul>
-<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/GraphComputer.ResultGraph.html" title="enum in org.apache.tinkerpop.gremlin.process.computer"><span class="typeNameLink">GraphComputer.ResultGraph</span></a></li>
<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/MapReduce.Stage.html" title="enum in org.apache.tinkerpop.gremlin.process.computer"><span class="typeNameLink">MapReduce.Stage</span></a></li>
<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/GraphComputer.Persist.html" title="enum in org.apache.tinkerpop.gremlin.process.computer"><span class="typeNameLink">GraphComputer.Persist</span></a></li>
-<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/GraphFilter.Legal.html" title="enum in org.apache.tinkerpop.gremlin.process.computer"><span class="typeNameLink">GraphFilter.Legal</span></a></li>
<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/ProgramPhase.html" title="enum in org.apache.tinkerpop.gremlin.process.computer"><span class="typeNameLink">ProgramPhase</span></a></li>
+<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/GraphComputer.ResultGraph.html" title="enum in org.apache.tinkerpop.gremlin.process.computer"><span class="typeNameLink">GraphComputer.ResultGraph</span></a></li>
+<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/GraphFilter.Legal.html" title="enum in org.apache.tinkerpop.gremlin.process.computer"><span class="typeNameLink">GraphFilter.Legal</span></a></li>
</ul>
</li>
</ul>
Modified: tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/Order.html
URL: http://svn.apache.org/viewvc/tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/Order.html?rev=1764939&r1=1764938&r2=1764939&view=diff
==============================================================================
--- tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/Order.html (original)
+++ tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/Order.html Fri Oct 14 16:01:29 2016
@@ -2,10 +2,10 @@
<!-- NewPage -->
<html lang="en">
<head>
-<!-- Generated by javadoc (1.8.0_101) on Tue Oct 04 15:40:52 EDT 2016 -->
+<!-- Generated by javadoc (1.8.0_101) on Fri Oct 14 12:00:06 EDT 2016 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Order (Apache TinkerPop 3.2.3-SNAPSHOT API)</title>
-<meta name="date" content="2016-10-04">
+<meta name="date" content="2016-10-14">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../../script.js"></script>
</head>
@@ -232,7 +232,7 @@ the order they are declared.</div>
<!-- -->
</a>
<h3>Methods inherited from class java.lang.<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
-<code><a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#equals-java.lang.Object-" title="class or interface in java.lang">equals</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass--" title="class or interface in java.lang">getClass</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify--" title="class or interface in java.lang">notify</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll--" title="class or interface in java.lang">notifyAll</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait--" title="class or interface in java.lang">wait</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-" title="class or interface in java.lang">wait</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Obj
ect.html?is-external=true#wait-long-int-" title="class or interface in java.lang">wait</a></code></li>
+<code><a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass--" title="class or interface in java.lang">getClass</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify--" title="class or interface in java.lang">notify</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll--" title="class or interface in java.lang">notifyAll</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait--" title="class or interface in java.lang">wait</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-" title="class or interface in java.lang">wait</a>, <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-int-" title="class or interface in java.lang">wait</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.util.Comparator">