You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by dk...@apache.org on 2016/10/04 16:40:03 UTC
svn commit: r1763297 [2/26] - in /tinkerpop/site:
docs/3.2.3-SNAPSHOT/dev/provider/ docs/3.2.3-SNAPSHOT/recipes/
docs/3.2.3-SNAPSHOT/reference/ docs/3.2.3-SNAPSHOT/tutorials/getting-started/
docs/3.2.3-SNAPSHOT/tutorials/the-gremlin-console/ docs/3.2.3...
Modified: tinkerpop/site/docs/3.2.3-SNAPSHOT/recipes/index.html
URL: http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.3-SNAPSHOT/recipes/index.html?rev=1763297&r1=1763296&r2=1763297&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.3-SNAPSHOT/recipes/index.html (original)
+++ tinkerpop/site/docs/3.2.3-SNAPSHOT/recipes/index.html Tue Oct 4 16:40:01 2016
@@ -864,23 +864,14 @@ traversal on the paths found between the
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V(<span class="integer">1</span>).bothE() <span class="comment">//</span><b>(1)</b>
-==>e[<span class="integer">9</span>][<span class="integer">1</span>-created-><span class="integer">3</span>]
-==>e[<span class="integer">7</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>]
-==>e[<span class="integer">8</span>][<span class="integer">1</span>-knows-><span class="integer">4</span>]
-gremlin> g.V(<span class="integer">1</span>).bothE().where(otherV().hasId(<span class="integer">2</span>)) <span class="comment">//</span><b>(2)</b>
-==>e[<span class="integer">7</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>]
-gremlin> v1 = g.V(<span class="integer">1</span>).next();<span class="type">[]</span>
-gremlin> v2 = g.V(<span class="integer">2</span>).next();<span class="type">[]</span>
-gremlin> g.V(v1).bothE().where(otherV().is(v2)) <span class="comment">//</span><b>(3)</b>
-==>e[<span class="integer">7</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>]
-gremlin> g.V(v1).outE().where(inV().is(v2)) <span class="comment">//</span><b>(4)</b>
-==>e[<span class="integer">7</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>]
-gremlin> g.V(<span class="integer">1</span>).outE().where(inV().has(id, within(<span class="integer">2</span>,<span class="integer">3</span>))) <span class="comment">//</span><b>(5)</b>
-==>e[<span class="integer">9</span>][<span class="integer">1</span>-created-><span class="integer">3</span>]
-==>e[<span class="integer">7</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>]
-gremlin> g.V(<span class="integer">1</span>).out().where(__.in().hasId(<span class="integer">6</span>)) <span class="comment">//</span><b>(6)</b>
-==>v[<span class="integer">3</span>]</code></pre>
+<pre>g.V(1).bothE() <b>(1)</b>
+g.V(1).bothE().where(otherV().hasId(2)) <b>(2)</b>
+v1 = g.V(1).next();[]
+v2 = g.V(2).next();[]
+g.V(v1).bothE().where(otherV().is(v2)) <b>(3)</b>
+g.V(v1).outE().where(inV().is(v2)) <b>(4)</b>
+g.V(1).outE().where(inV().has(id, within(2,3))) <b>(5)</b>
+g.V(1).out().where(__.in().hasId(6)) <b>(6)</b></pre>
</div>
</div>
<div class="colist arabic">
@@ -916,20 +907,11 @@ vertices:</p>
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> ids = [<span class="integer">2</span>,<span class="integer">4</span>,<span class="integer">6</span>].toArray()
-==><span class="integer">2</span>
-==><span class="integer">4</span>
-==><span class="integer">6</span>
-gremlin> g.V(ids).as(<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>).
- repeat(bothE().otherV().simplePath()).times(<span class="integer">5</span>).emit(hasId(within(ids))).as(<span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>).
- filter(select(last,<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(id).where(<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>, lt(<span class="string"><span class="delimiter">"</span><span class="content">b</span><span class="delimiter">"</span></span>))).
- path().by().by(label)
-==>[v[<span class="integer">2</span>],knows,v[<span class="integer">1</span>],knows,v[<span class="integer">4</span>]]
-==>[v[<span class="integer">2</span>],knows,v[<span class="integer">1</span>],created,v[<span class="integer">3</span>],created,v[<span class="integer">4</span>]]
-==>[v[<span class="integer">2</span>],knows,v[<span class="integer">1</span>],created,v[<span class="integer">3</span>],created,v[<span class="integer">6</span>]]
-==>[v[<span class="integer">2</span>],knows,v[<span class="integer">1</span>],knows,v[<span class="integer">4</span>],created,v[<span class="integer">3</span>],created,v[<span class="integer">6</span>]]
-==>[v[<span class="integer">4</span>],created,v[<span class="integer">3</span>],created,v[<span class="integer">6</span>]]
-==>[v[<span class="integer">4</span>],knows,v[<span class="integer">1</span>],created,v[<span class="integer">3</span>],created,v[<span class="integer">6</span>]]</code></pre>
+<pre>ids = [2,4,6].toArray()
+g.V(ids).as("a").
+ repeat(bothE().otherV().simplePath()).times(5).emit(hasId(within(ids))).as("b").
+ filter(select(last,"a","b").by(id).where("a", lt("b"))).
+ path().by().by(label)</pre>
</div>
</div>
<div class="paragraph">
@@ -945,73 +927,46 @@ the known person completed an applicatio
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> vBob = graph.addVertex(label, <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">name</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">bob</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">0</span>]
-gremlin> vStephen = graph.addVertex(label, <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">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">2</span>]
-gremlin> vBlueprintsInc = graph.addVertex(label, <span class="string"><span class="delimiter">"</span><span class="content">company</span><span class="delimiter">"</span></span>, <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">Blueprints, Inc</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">4</span>]
-gremlin> vRexsterLlc = graph.addVertex(label, <span class="string"><span class="delimiter">"</span><span class="content">company</span><span class="delimiter">"</span></span>, <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">Rexster, LLC</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">6</span>]
-gremlin> vBlueprintsJob1 = graph.addVertex(label, <span class="string"><span class="delimiter">"</span><span class="content">job</span><span class="delimiter">"</span></span>, <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">job1</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">8</span>]
-gremlin> vBlueprintsJob2 = graph.addVertex(label, <span class="string"><span class="delimiter">"</span><span class="content">job</span><span class="delimiter">"</span></span>, <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">job2</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">10</span>]
-gremlin> vBlueprintsJob3 = graph.addVertex(label, <span class="string"><span class="delimiter">"</span><span class="content">job</span><span class="delimiter">"</span></span>, <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">job3</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">12</span>]
-gremlin> vRexsterJob1 = graph.addVertex(label, <span class="string"><span class="delimiter">"</span><span class="content">job</span><span class="delimiter">"</span></span>, <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">job4</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">14</span>]
-gremlin> vAppBob1 = graph.addVertex(label, <span class="string"><span class="delimiter">"</span><span class="content">application</span><span class="delimiter">"</span></span>, <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">application1</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">16</span>]
-gremlin> vAppBob2 = graph.addVertex(label, <span class="string"><span class="delimiter">"</span><span class="content">application</span><span class="delimiter">"</span></span>, <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">application2</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">18</span>]
-gremlin> vAppStephen1 = graph.addVertex(label, <span class="string"><span class="delimiter">"</span><span class="content">application</span><span class="delimiter">"</span></span>, <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">application3</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">20</span>]
-gremlin> vAppStephen2 = graph.addVertex(label, <span class="string"><span class="delimiter">"</span><span class="content">application</span><span class="delimiter">"</span></span>, <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">application4</span><span class="delimiter">"</span></span>)
-==>v[<span class="integer">22</span>]
-gremlin> vBob.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">completes</span><span class="delimiter">"</span></span>, vAppBob1)
-==>e[<span class="integer">24</span>][<span class="integer">0</span>-completes-><span class="integer">16</span>]
-gremlin> vBob.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">completes</span><span class="delimiter">"</span></span>, vAppBob2)
-==>e[<span class="integer">25</span>][<span class="integer">0</span>-completes-><span class="integer">18</span>]
-gremlin> vStephen.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">completes</span><span class="delimiter">"</span></span>, vAppStephen1)
-==>e[<span class="integer">26</span>][<span class="integer">2</span>-completes-><span class="integer">20</span>]
-gremlin> vStephen.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">completes</span><span class="delimiter">"</span></span>, vAppStephen2)
-==>e[<span class="integer">27</span>][<span class="integer">2</span>-completes-><span class="integer">22</span>]
-gremlin> vAppBob1.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">appliesTo</span><span class="delimiter">"</span></span>, vBlueprintsJob1)
-==>e[<span class="integer">28</span>][<span class="integer">16</span>-appliesTo-><span class="integer">8</span>]
-gremlin> vAppBob2.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">appliesTo</span><span class="delimiter">"</span></span>, vBlueprintsJob2)
-==>e[<span class="integer">29</span>][<span class="integer">18</span>-appliesTo-><span class="integer">10</span>]
-gremlin> vAppStephen1.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">appliesTo</span><span class="delimiter">"</span></span>, vRexsterJob1)
-==>e[<span class="integer">30</span>][<span class="integer">20</span>-appliesTo-><span class="integer">14</span>]
-gremlin> vAppStephen2.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">appliesTo</span><span class="delimiter">"</span></span>, vBlueprintsJob3)
-==>e[<span class="integer">31</span>][<span class="integer">22</span>-appliesTo-><span class="integer">12</span>]
-gremlin> vBlueprintsInc.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">created</span><span class="delimiter">"</span></span>, vBlueprintsJob1, <span class="string"><span class="delimiter">"</span><span class="content">creationDate</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">12/20/2015</span><span class="delimiter">"</span></span>)
-==>e[<span class="integer">32</span>][<span class="integer">4</span>-created-><span class="integer">8</span>]
-gremlin> vBlueprintsInc.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">created</span><span class="delimiter">"</span></span>, vBlueprintsJob2, <span class="string"><span class="delimiter">"</span><span class="content">creationDate</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">12/15/2015</span><span class="delimiter">"</span></span>)
-==>e[<span class="integer">33</span>][<span class="integer">4</span>-created-><span class="integer">10</span>]
-gremlin> vBlueprintsInc.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">created</span><span class="delimiter">"</span></span>, vBlueprintsJob3, <span class="string"><span class="delimiter">"</span><span class="content">creationDate</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">12/16/2015</span><span class="delimiter">"</span></span>)
-==>e[<span class="integer">34</span>][<span class="integer">4</span>-created-><span class="integer">12</span>]
-gremlin> vRexsterLlc.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">created</span><span class="delimiter">"</span></span>, vRexsterJob1, <span class="string"><span class="delimiter">"</span><span class="content">creationDate</span><span class="delimiter">"</span></span>, <span class="string"><span class="delimiter">"</span><span class="content">12/18/2015</span><span class="delimiter">"</span></span>)
-==>e[<span class="integer">35</span>][<span class="integer">6</span>-created-><span class="integer">14</span>]
-gremlin> g.V(vRexsterJob1).as(<span class="string"><span class="delimiter">'</span><span class="content">job</span><span class="delimiter">'</span></span>).
- inE(<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">created</span><span class="delimiter">'</span></span>).
- outV().as(<span class="string"><span class="delimiter">'</span><span class="content">company</span><span class="delimiter">'</span></span>).
- select(<span class="string"><span class="delimiter">'</span><span class="content">job</span><span class="delimiter">'</span></span>).
- coalesce(__.in(<span class="string"><span class="delimiter">'</span><span class="content">appliesTo</span><span class="delimiter">'</span></span>).where(__.in(<span class="string"><span class="delimiter">'</span><span class="content">completes</span><span class="delimiter">'</span></span>).is(vStephen)),
- constant(<span class="predefined-constant">false</span>)).as(<span class="string"><span class="delimiter">'</span><span class="content">application</span><span class="delimiter">'</span></span>).
- select(<span class="string"><span class="delimiter">'</span><span class="content">job</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">company</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">application</span><span class="delimiter">'</span></span>).
- by().by().by(<span class="string"><span class="delimiter">'</span><span class="content">creationDate</span><span class="delimiter">'</span></span>).by()
-==>[<span class="key">job</span>:v[<span class="integer">14</span>],<span class="key">company</span>:v[<span class="integer">6</span>],<span class="key">created</span>:<span class="integer">12</span>/<span class="integer">18</span>/<span class="integer">2015</span>,<span class="key">application</span>:v[<span class="integer">20</span>]]
-gremlin> g.V(vRexsterJob1, vBlueprintsJob1).as(<span class="string"><span class="delimiter">'</span><span class="content">job</span><span class="delimiter">'</span></span>).
- inE(<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">created</span><span class="delimiter">'</span></span>).
- outV().as(<span class="string"><span class="delimiter">'</span><span class="content">company</span><span class="delimiter">'</span></span>).
- select(<span class="string"><span class="delimiter">'</span><span class="content">job</span><span class="delimiter">'</span></span>).
- coalesce(__.in(<span class="string"><span class="delimiter">'</span><span class="content">appliesTo</span><span class="delimiter">'</span></span>).where(__.in(<span class="string"><span class="delimiter">'</span><span class="content">completes</span><span class="delimiter">'</span></span>).is(vBob)),
- constant(<span class="predefined-constant">false</span>)).as(<span class="string"><span class="delimiter">'</span><span class="content">application</span><span class="delimiter">'</span></span>).
- select(<span class="string"><span class="delimiter">'</span><span class="content">job</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">company</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">application</span><span class="delimiter">'</span></span>).
- by().by().by(<span class="string"><span class="delimiter">'</span><span class="content">creationDate</span><span class="delimiter">'</span></span>).by()
-==>[<span class="key">job</span>:v[<span class="integer">14</span>],<span class="key">company</span>:v[<span class="integer">6</span>],<span class="key">created</span>:<span class="integer">12</span>/<span class="integer">18</span>/<span class="integer">2015</span>,<span class="key">application</span>:<span class="predefined-constant">false</span>]
-==>[<span class="key">job</span>:v[<span class="integer">8</span>],<span class="key">company</span>:v[<span class="integer">4</span>],<span class="key">created</span>:<span class="integer">12</span>/<span class="integer">20</span>/<span class="integer">2015</span>,<span class="key">application</span>:v[<span class="integer">16</span>]]</code></pre>
+<pre>vBob = graph.addVertex(label, "person", "name", "bob")
+vStephen = graph.addVertex(label, "person", "name", "stephen")
+vBlueprintsInc = graph.addVertex(label, "company", "name", "Blueprints, Inc")
+vRexsterLlc = graph.addVertex(label, "company", "name", "Rexster, LLC")
+vBlueprintsJob1 = graph.addVertex(label, "job", "name", "job1")
+vBlueprintsJob2 = graph.addVertex(label, "job", "name", "job2")
+vBlueprintsJob3 = graph.addVertex(label, "job", "name", "job3")
+vRexsterJob1 = graph.addVertex(label, "job", "name", "job4")
+vAppBob1 = graph.addVertex(label, "application", "name", "application1")
+vAppBob2 = graph.addVertex(label, "application", "name", "application2")
+vAppStephen1 = graph.addVertex(label, "application", "name", "application3")
+vAppStephen2 = graph.addVertex(label, "application", "name", "application4")
+vBob.addEdge("completes", vAppBob1)
+vBob.addEdge("completes", vAppBob2)
+vStephen.addEdge("completes", vAppStephen1)
+vStephen.addEdge("completes", vAppStephen2)
+vAppBob1.addEdge("appliesTo", vBlueprintsJob1)
+vAppBob2.addEdge("appliesTo", vBlueprintsJob2)
+vAppStephen1.addEdge("appliesTo", vRexsterJob1)
+vAppStephen2.addEdge("appliesTo", vBlueprintsJob3)
+vBlueprintsInc.addEdge("created", vBlueprintsJob1, "creationDate", "12/20/2015")
+vBlueprintsInc.addEdge("created", vBlueprintsJob2, "creationDate", "12/15/2015")
+vBlueprintsInc.addEdge("created", vBlueprintsJob3, "creationDate", "12/16/2015")
+vRexsterLlc.addEdge("created", vRexsterJob1, "creationDate", "12/18/2015")
+g.V(vRexsterJob1).as('job').
+ inE('created').as('created').
+ outV().as('company').
+ select('job').
+ coalesce(__.in('appliesTo').where(__.in('completes').is(vStephen)),
+ constant(false)).as('application').
+ select('job', 'company', 'created', 'application').
+ by().by().by('creationDate').by()
+g.V(vRexsterJob1, vBlueprintsJob1).as('job').
+ inE('created').as('created').
+ outV().as('company').
+ select('job').
+ coalesce(__.in('appliesTo').where(__.in('completes').is(vBob)),
+ constant(false)).as('application').
+ select('job', 'company', 'created', 'application').
+ by().by().by('creationDate').by()</pre>
</div>
</div>
<div class="paragraph">
@@ -1035,39 +990,22 @@ is a simple example that identifies the
</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> v1 = graph.addVertex(T.id, <span class="integer">1</span>)
-==>v[<span class="integer">1</span>]
-gremlin> v2 = graph.addVertex(T.id, <span class="integer">2</span>)
-==>v[<span class="integer">2</span>]
-gremlin> v3 = graph.addVertex(T.id, <span class="integer">3</span>)
-==>v[<span class="integer">3</span>]
-gremlin> v4 = graph.addVertex(T.id, <span class="integer">4</span>)
-==>v[<span class="integer">4</span>]
-gremlin> v5 = graph.addVertex(T.id, <span class="integer">5</span>)
-==>v[<span class="integer">5</span>]
-gremlin> v1.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, v2)
-==>e[<span class="integer">0</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>]
-gremlin> v2.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, v4)
-==>e[<span class="integer">1</span>][<span class="integer">2</span>-knows-><span class="integer">4</span>]
-gremlin> v4.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, v5)
-==>e[<span class="integer">2</span>][<span class="integer">4</span>-knows-><span class="integer">5</span>]
-gremlin> v2.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, v3)
-==>e[<span class="integer">3</span>][<span class="integer">2</span>-knows-><span class="integer">3</span>]
-gremlin> v3.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, v4)
-==>e[<span class="integer">4</span>][<span class="integer">3</span>-knows-><span class="integer">4</span>]
-gremlin> g = graph.traversal()
-==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">5</span> <span class="key">edges</span>:<span class="integer">5</span>], standard]
-gremlin> g.V(<span class="integer">1</span>).repeat(out().simplePath()).until(hasId(<span class="integer">5</span>)).path().limit(<span class="integer">1</span>) <span class="comment">//</span><b>(1)</b>
-==>[v[<span class="integer">1</span>],v[<span class="integer">2</span>],v[<span class="integer">4</span>],v[<span class="integer">5</span>]]
-gremlin> g.V(<span class="integer">1</span>).repeat(out().simplePath()).until(hasId(<span class="integer">5</span>)).path().count(local) <span class="comment">//</span><b>(2)</b>
-==><span class="integer">4</span>
-==><span class="integer">5</span>
-gremlin> g.V(<span class="integer">1</span>).repeat(out().simplePath()).until(hasId(<span class="integer">5</span>)).path().
- group().by(count(local)).next() <span class="comment">//</span><b>(3)</b>
-==><span class="integer">4</span>=[[v[<span class="integer">1</span>], v[<span class="integer">2</span>], v[<span class="integer">4</span>], v[<span class="integer">5</span>]]]
-==><span class="integer">5</span>=[[v[<span class="integer">1</span>], v[<span class="integer">2</span>], v[<span class="integer">3</span>], v[<span class="integer">4</span>], v[<span class="integer">5</span>]]]</code></pre>
+<pre>graph = TinkerGraph.open()
+v1 = graph.addVertex(T.id, 1)
+v2 = graph.addVertex(T.id, 2)
+v3 = graph.addVertex(T.id, 3)
+v4 = graph.addVertex(T.id, 4)
+v5 = graph.addVertex(T.id, 5)
+v1.addEdge("knows", v2)
+v2.addEdge("knows", v4)
+v4.addEdge("knows", v5)
+v2.addEdge("knows", v3)
+v3.addEdge("knows", v4)
+g = graph.traversal()
+g.V(1).repeat(out().simplePath()).until(hasId(5)).path().limit(1) <b>(1)</b>
+g.V(1).repeat(out().simplePath()).until(hasId(5)).path().count(local) <b>(2)</b>
+g.V(1).repeat(out().simplePath()).until(hasId(5)).path().
+ group().by(count(local)).next() <b>(3)</b></pre>
</div>
</div>
<div class="colist arabic">
@@ -1094,51 +1032,31 @@ but includes a "weight" on the edges, th
</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> v1 = graph.addVertex(T.id, <span class="integer">1</span>)
-==>v[<span class="integer">1</span>]
-gremlin> v2 = graph.addVertex(T.id, <span class="integer">2</span>)
-==>v[<span class="integer">2</span>]
-gremlin> v3 = graph.addVertex(T.id, <span class="integer">3</span>)
-==>v[<span class="integer">3</span>]
-gremlin> v4 = graph.addVertex(T.id, <span class="integer">4</span>)
-==>v[<span class="integer">4</span>]
-gremlin> v5 = graph.addVertex(T.id, <span class="integer">5</span>)
-==>v[<span class="integer">5</span>]
-gremlin> v1.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, v2, <span class="string"><span class="delimiter">"</span><span class="content">weight</span><span class="delimiter">"</span></span>, <span class="float">1.25</span>)
-==>e[<span class="integer">0</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>]
-gremlin> v2.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, v4, <span class="string"><span class="delimiter">"</span><span class="content">weight</span><span class="delimiter">"</span></span>, <span class="float">1.5</span>)
-==>e[<span class="integer">1</span>][<span class="integer">2</span>-knows-><span class="integer">4</span>]
-gremlin> v4.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, v5, <span class="string"><span class="delimiter">"</span><span class="content">weight</span><span class="delimiter">"</span></span>, <span class="float">0.25</span>)
-==>e[<span class="integer">2</span>][<span class="integer">4</span>-knows-><span class="integer">5</span>]
-gremlin> v2.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, v3, <span class="string"><span class="delimiter">"</span><span class="content">weight</span><span class="delimiter">"</span></span>, <span class="float">0.25</span>)
-==>e[<span class="integer">3</span>][<span class="integer">2</span>-knows-><span class="integer">3</span>]
-gremlin> v3.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, v4, <span class="string"><span class="delimiter">"</span><span class="content">weight</span><span class="delimiter">"</span></span>, <span class="float">0.25</span>)
-==>e[<span class="integer">4</span>][<span class="integer">3</span>-knows-><span class="integer">4</span>]
-gremlin> g = graph.traversal()
-==>graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span class="integer">5</span> <span class="key">edges</span>:<span class="integer">5</span>], standard]
-gremlin> g.V(<span class="integer">1</span>).repeat(out().simplePath()).until(hasId(<span class="integer">5</span>)).path().
- group().by(count(local)).next() <span class="comment">//</span><b>(1)</b>
-==><span class="integer">4</span>=[[v[<span class="integer">1</span>], v[<span class="integer">2</span>], v[<span class="integer">4</span>], v[<span class="integer">5</span>]]]
-==><span class="integer">5</span>=[[v[<span class="integer">1</span>], v[<span class="integer">2</span>], v[<span class="integer">3</span>], v[<span class="integer">4</span>], v[<span class="integer">5</span>]]]
-gremlin> g.V(<span class="integer">1</span>).repeat(outE().inV().simplePath()).until(hasId(<span class="integer">5</span>)).
- path().by(coalesce(values(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>),
- constant(<span class="float">0.0</span>))).
- map(unfold().sum()) <span class="comment">//</span><b>(2)</b>
-==><span class="float">3.00</span>
-==><span class="float">2.00</span>
-gremlin> g.V(<span class="integer">1</span>).repeat(outE().inV().simplePath()).until(hasId(<span class="integer">5</span>)).
- path().by(constant(<span class="float">0.0</span>)).by(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>).map(unfold().sum()) <span class="comment">//</span><b>(3)</b>
-==><span class="float">3.00</span>
-==><span class="float">2.00</span>
-gremlin> g.V(<span class="integer">1</span>).repeat(outE().inV().simplePath()).until(hasId(<span class="integer">5</span>)).
- path().as(<span class="string"><span class="delimiter">'</span><span class="content">p</span><span class="delimiter">'</span></span>).
- map(unfold().coalesce(values(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>),
- constant(<span class="float">0.0</span>)).sum()).as(<span class="string"><span class="delimiter">'</span><span class="content">cost</span><span class="delimiter">'</span></span>).
- select(<span class="string"><span class="delimiter">'</span><span class="content">cost</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">p</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(4)</b>
-==>[<span class="key">cost</span>:<span class="float">3.00</span>,<span class="key">p</span>:[v[<span class="integer">1</span>],e[<span class="integer">0</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>],v[<span class="integer">2</span>],e[<span class="integer">1</span>][<span class="integer">2</span>-knows-><span class="integer">4</span>],v[<span class="integer">4</span>],e[<span class="integer">2</span>][<span class="integer">4</span>-knows-><span class="integer">5</span>],v[<span class="integer">5</span>]]]
-==>[<span class="key">cost</span>:<span class="float">2.00</span>,<span class="key">p</span>:[v[<span class="integer">1</span>],e[<span class="integer">0</span>][<span class="integer">1</span>-knows-><span class="integer">2</span>],v[<span class="integer">2</span>],e[<span class="integer">3</span>][<span class="integer">2</span>-knows-><span class="integer">3</span>],v[<span class="integer">3</span>],e[<span class="integer">4</span>][<span class="integer">3</span>-knows-><span class="integer">4</span>],v[<span class="integer">4</span>],e[<span class="integer">2</span>][<span class="integer">4</span>-knows-><span class="integer">5</span>],v[<span class="integer">5</span>]]]</code></pre>
+<pre>graph = TinkerGraph.open()
+v1 = graph.addVertex(T.id, 1)
+v2 = graph.addVertex(T.id, 2)
+v3 = graph.addVertex(T.id, 3)
+v4 = graph.addVertex(T.id, 4)
+v5 = graph.addVertex(T.id, 5)
+v1.addEdge("knows", v2, "weight", 1.25)
+v2.addEdge("knows", v4, "weight", 1.5)
+v4.addEdge("knows", v5, "weight", 0.25)
+v2.addEdge("knows", v3, "weight", 0.25)
+v3.addEdge("knows", v4, "weight", 0.25)
+g = graph.traversal()
+g.V(1).repeat(out().simplePath()).until(hasId(5)).path().
+ group().by(count(local)).next() <b>(1)</b>
+g.V(1).repeat(outE().inV().simplePath()).until(hasId(5)).
+ path().by(coalesce(values('weight'),
+ constant(0.0))).
+ map(unfold().sum()) <b>(2)</b>
+g.V(1).repeat(outE().inV().simplePath()).until(hasId(5)).
+ path().by(constant(0.0)).by('weight').map(unfold().sum()) <b>(3)</b>
+g.V(1).repeat(outE().inV().simplePath()).until(hasId(5)).
+ path().as('p').
+ map(unfold().coalesce(values('weight'),
+ constant(0.0)).sum()).as('cost').
+ select('cost','p') <b>(4)</b></pre>
</div>
</div>
<div class="colist arabic">
@@ -1177,8 +1095,7 @@ structure.</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>).groupCount().by(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>)
-==>[<span class="integer">32</span>:<span class="integer">1</span>,<span class="integer">35</span>:<span class="integer">1</span>,<span class="integer">27</span>:<span class="integer">1</span>,<span class="integer">29</span>:<span class="integer">1</span>]</code></pre>
+<pre>g.V().hasLabel('person').groupCount().by('age')</pre>
</div>
</div>
<div class="paragraph">
@@ -1189,12 +1106,11 @@ a domain concept such as "young", "old"
</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>).groupCount().by(values(<span class="string"><span class="delimiter">"</span><span class="content">age</span><span class="delimiter">"</span></span>).choose(
- is(lt(<span class="integer">28</span>)),constant(<span class="string"><span class="delimiter">"</span><span class="content">young</span><span class="delimiter">"</span></span>),
- choose(is(lt(<span class="integer">30</span>)),
- constant(<span class="string"><span class="delimiter">"</span><span class="content">old</span><span class="delimiter">"</span></span>),
- constant(<span class="string"><span class="delimiter">"</span><span class="content">very old</span><span class="delimiter">"</span></span>))))
-==>[<span class="key">young</span>:<span class="integer">1</span>,<span class="key">old</span>:<span class="integer">1</span>,very <span class="key">old</span>:<span class="integer">2</span>]</code></pre>
+<pre>g.V().hasLabel("person").groupCount().by(values("age").choose(
+ is(lt(28)),constant("young"),
+ choose(is(lt(30)),
+ constant("old"),
+ constant("very old"))))</pre>
</div>
</div>
<div class="paragraph">
@@ -1221,12 +1137,11 @@ there is another option to consider with
</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>).
- groupCount().by(values(<span class="string"><span class="delimiter">"</span><span class="content">age</span><span class="delimiter">"</span></span>).
- coalesce(is(lt(<span class="integer">28</span>)).constant(<span class="string"><span class="delimiter">"</span><span class="content">young</span><span class="delimiter">"</span></span>),
- is(lt(<span class="integer">30</span>)).constant(<span class="string"><span class="delimiter">"</span><span class="content">old</span><span class="delimiter">"</span></span>),
- constant(<span class="string"><span class="delimiter">"</span><span class="content">very old</span><span class="delimiter">"</span></span>)))
-==>[<span class="key">young</span>:<span class="integer">1</span>,<span class="key">old</span>:<span class="integer">1</span>,very <span class="key">old</span>:<span class="integer">2</span>]</code></pre>
+<pre>g.V().hasLabel("person").
+ groupCount().by(values("age").
+ coalesce(is(lt(28)).constant("young"),
+ is(lt(30)).constant("old"),
+ constant("very old")))</pre>
</div>
</div>
<div class="paragraph">
@@ -1246,33 +1161,20 @@ depticted below Gremlin could be use to
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> vA = graph.addVertex(id, <span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>)
-==>v[a]
-gremlin> vB = graph.addVertex(id, <span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>)
-==>v[b]
-gremlin> vC = graph.addVertex(id, <span class="string"><span class="delimiter">'</span><span class="content">c</span><span class="delimiter">'</span></span>)
-==>v[c]
-gremlin> vD = graph.addVertex(id, <span class="string"><span class="delimiter">'</span><span class="content">d</span><span class="delimiter">'</span></span>)
-==>v[d]
-gremlin> vA.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, vB)
-==>e[<span class="integer">0</span>][a-knows->b]
-gremlin> vB.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, vC)
-==>e[<span class="integer">1</span>][b-knows->c]
-gremlin> vC.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, vA)
-==>e[<span class="integer">2</span>][c-knows->a]
-gremlin> vA.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, vD)
-==>e[<span class="integer">3</span>][a-knows->d]
-gremlin> vC.addEdge(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>, vD)
-==>e[<span class="integer">4</span>][c-knows->d]
-gremlin> g.V().as(<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>).repeat(out().simplePath()).times(<span class="integer">2</span>).
- where(out().as(<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>)).path() <span class="comment">//</span><b>(1)</b>
-==>[v[a],v[b],v[c]]
-==>[v[b],v[c],v[a]]
-==>[v[c],v[a],v[b]]
-gremlin> g.V().as(<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>).repeat(out().simplePath()).times(<span class="integer">2</span>).
- where(out().as(<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>)).path().
- dedup().by(unfold().order().by(id).dedup().fold()) <span class="comment">//</span><b>(2)</b>
-==>[v[a],v[b],v[c]]</code></pre>
+<pre>vA = graph.addVertex(id, 'a')
+vB = graph.addVertex(id, 'b')
+vC = graph.addVertex(id, 'c')
+vD = graph.addVertex(id, 'd')
+vA.addEdge("knows", vB)
+vB.addEdge("knows", vC)
+vC.addEdge("knows", vA)
+vA.addEdge("knows", vD)
+vC.addEdge("knows", vD)
+g.V().as("a").repeat(out().simplePath()).times(2).
+ where(out().as("a")).path() <b>(1)</b>
+g.V().as("a").repeat(out().simplePath()).times(2).
+ where(out().as("a")).path().
+ dedup().by(unfold().order().by(id).dedup().fold()) <b>(2)</b></pre>
</div>
</div>
<div class="colist arabic">
@@ -1297,10 +1199,9 @@ arbitrary length over both incoming and
</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>).repeat(both().simplePath()).emit(loops().is(gt(<span class="integer">1</span>))).
- both().where(eq(<span class="string"><span class="delimiter">"</span><span class="content">a</span><span class="delimiter">"</span></span>)).path().
- dedup().by(unfold().order().by(id).dedup().fold())
-==>[v[<span class="integer">1</span>],v[<span class="integer">3</span>],v[<span class="integer">4</span>],v[<span class="integer">1</span>]]</code></pre>
+<pre>g.V().as("a").repeat(both().simplePath()).emit(loops().is(gt(1))).
+ both().where(eq("a")).path().
+ dedup().by(unfold().order().by(id).dedup().fold())</pre>
</div>
</div>
</div>
@@ -1321,26 +1222,13 @@ edges associated to each vertex.</p>
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().group().by().by(bothE().count()) <span class="comment">//</span><b>(1)</b>
-==>[v[<span class="integer">1</span>]:<span class="integer">3</span>,v[<span class="integer">2</span>]:<span class="integer">1</span>,v[<span class="integer">3</span>]:<span class="integer">3</span>,v[<span class="integer">4</span>]:<span class="integer">3</span>,v[<span class="integer">5</span>]:<span class="integer">1</span>,v[<span class="integer">6</span>]:<span class="integer">1</span>]
-gremlin> g.V().group().by().by(inE().count()) <span class="comment">//</span><b>(2)</b>
-==>[v[<span class="integer">1</span>]:<span class="integer">0</span>,v[<span class="integer">2</span>]:<span class="integer">1</span>,v[<span class="integer">3</span>]:<span class="integer">3</span>,v[<span class="integer">4</span>]:<span class="integer">1</span>,v[<span class="integer">5</span>]:<span class="integer">1</span>,v[<span class="integer">6</span>]:<span class="integer">0</span>]
-gremlin> g.V().group().by().by(outE().count()) <span class="comment">//</span><b>(3)</b>
-==>[v[<span class="integer">1</span>]:<span class="integer">3</span>,v[<span class="integer">2</span>]:<span class="integer">0</span>,v[<span class="integer">3</span>]:<span class="integer">0</span>,v[<span class="integer">4</span>]:<span class="integer">2</span>,v[<span class="integer">5</span>]:<span class="integer">0</span>,v[<span class="integer">6</span>]:<span class="integer">1</span>]
-gremlin> g.V().project(<span class="string"><span class="delimiter">"</span><span class="content">v</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">degree</span><span class="delimiter">"</span></span>).by().by(bothE().count()) <span class="comment">//</span><b>(4)</b>
-==>[<span class="key">v</span>:v[<span class="integer">1</span>],<span class="key">degree</span>:<span class="integer">3</span>]
-==>[<span class="key">v</span>:v[<span class="integer">2</span>],<span class="key">degree</span>:<span class="integer">1</span>]
-==>[<span class="key">v</span>:v[<span class="integer">3</span>],<span class="key">degree</span>:<span class="integer">3</span>]
-==>[<span class="key">v</span>:v[<span class="integer">4</span>],<span class="key">degree</span>:<span class="integer">3</span>]
-==>[<span class="key">v</span>:v[<span class="integer">5</span>],<span class="key">degree</span>:<span class="integer">1</span>]
-==>[<span class="key">v</span>:v[<span class="integer">6</span>],<span class="key">degree</span>:<span class="integer">1</span>]
-gremlin> g.V().project(<span class="string"><span class="delimiter">"</span><span class="content">v</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">degree</span><span class="delimiter">"</span></span>).by().by(bothE().count()). <span class="comment">//</span><b>(5)</b>
- order().by(select(<span class="string"><span class="delimiter">"</span><span class="content">degree</span><span class="delimiter">"</span></span>), decr).
- limit(<span class="integer">4</span>)
-==>[<span class="key">v</span>:v[<span class="integer">1</span>],<span class="key">degree</span>:<span class="integer">3</span>]
-==>[<span class="key">v</span>:v[<span class="integer">3</span>],<span class="key">degree</span>:<span class="integer">3</span>]
-==>[<span class="key">v</span>:v[<span class="integer">4</span>],<span class="key">degree</span>:<span class="integer">3</span>]
-==>[<span class="key">v</span>:v[<span class="integer">2</span>],<span class="key">degree</span>:<span class="integer">1</span>]</code></pre>
+<pre>g.V().group().by().by(bothE().count()) <b>(1)</b>
+g.V().group().by().by(inE().count()) <b>(2)</b>
+g.V().group().by().by(outE().count()) <b>(3)</b>
+g.V().project("v","degree").by().by(bothE().count()) <b>(4)</b>
+g.V().project("v","degree").by().by(bothE().count()). <b>(5)</b>
+ order().by(select("degree"), decr).
+ limit(4)</pre>
</div>
</div>
<div class="colist arabic">
@@ -1394,39 +1282,25 @@ graph for demonstration purposes:</p>
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> a = graph.addVertex(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">a</span><span class="delimiter">'</span></span>)
-==>v[<span class="integer">0</span>]
-gremlin> b = graph.addVertex(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">b</span><span class="delimiter">'</span></span>)
-==>v[<span class="integer">2</span>]
-gremlin> c = graph.addVertex(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">c</span><span class="delimiter">'</span></span>)
-==>v[<span class="integer">4</span>]
-gremlin> d = graph.addVertex(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">d</span><span class="delimiter">'</span></span>)
-==>v[<span class="integer">6</span>]
-gremlin> e = graph.addVertex(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">e</span><span class="delimiter">'</span></span>)
-==>v[<span class="integer">8</span>]
-gremlin> a.addEdge(<span class="string"><span class="delimiter">'</span><span class="content">next</span><span class="delimiter">'</span></span>,b)
-==>e[<span class="integer">10</span>][<span class="integer">0</span>-next-><span class="integer">2</span>]
-gremlin> b.addEdge(<span class="string"><span class="delimiter">'</span><span class="content">next</span><span class="delimiter">'</span></span>,c)
-==>e[<span class="integer">11</span>][<span class="integer">2</span>-next-><span class="integer">4</span>]
-gremlin> c.addEdge(<span class="string"><span class="delimiter">'</span><span class="content">next</span><span class="delimiter">'</span></span>,d)
-==>e[<span class="integer">12</span>][<span class="integer">4</span>-next-><span class="integer">6</span>]
-gremlin> d.addEdge(<span class="string"><span class="delimiter">'</span><span class="content">next</span><span class="delimiter">'</span></span>,e)
-==>e[<span class="integer">13</span>][<span class="integer">6</span>-next-><span class="integer">8</span>]
-gremlin> g.withSack(<span class="integer">0</span>).V().store(<span class="string"><span class="delimiter">"</span><span class="content">x</span><span class="delimiter">"</span></span>).repeat(both().simplePath()).emit().path(). <span class="comment">//</span><b>(1)</b>
- group().by(project(<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(limit(local, <span class="integer">1</span>)). <span class="comment">//</span><b>(2)</b>
- by(tail(local, <span class="integer">1</span>))).
- by(order().by(count(local))). <span class="comment">//</span><b>(3)</b>
- select(values).as(<span class="string"><span class="delimiter">"</span><span class="content">shortestPaths</span><span class="delimiter">"</span></span>). <span class="comment">//</span><b>(4)</b>
- select(<span class="string"><span class="delimiter">"</span><span class="content">x</span><span class="delimiter">"</span></span>).unfold().as(<span class="string"><span class="delimiter">"</span><span class="content">v</span><span class="delimiter">"</span></span>). <span class="comment">//</span><b>(5)</b>
- select(<span class="string"><span class="delimiter">"</span><span class="content">shortestPaths</span><span class="delimiter">"</span></span>). <span class="comment">//</span><b>(6)</b>
- map(unfold().filter(unfold().where(eq(<span class="string"><span class="delimiter">"</span><span class="content">v</span><span class="delimiter">"</span></span>))).count()). <span class="comment">//</span><b>(7)</b>
- sack(sum).sack().as(<span class="string"><span class="delimiter">"</span><span class="content">betweeness</span><span class="delimiter">"</span></span>). <span class="comment">//</span><b>(8)</b>
- select(<span class="string"><span class="delimiter">"</span><span class="content">v</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">betweeness</span><span class="delimiter">"</span></span>)
-==>[<span class="key">v</span>:v[<span class="integer">0</span>],<span class="key">betweeness</span>:<span class="integer">8</span>]
-==>[<span class="key">v</span>:v[<span class="integer">2</span>],<span class="key">betweeness</span>:<span class="integer">14</span>]
-==>[<span class="key">v</span>:v[<span class="integer">4</span>],<span class="key">betweeness</span>:<span class="integer">16</span>]
-==>[<span class="key">v</span>:v[<span class="integer">6</span>],<span class="key">betweeness</span>:<span class="integer">14</span>]
-==>[<span class="key">v</span>:v[<span class="integer">8</span>],<span class="key">betweeness</span>:<span class="integer">8</span>]</code></pre>
+<pre>a = graph.addVertex('name','a')
+b = graph.addVertex('name','b')
+c = graph.addVertex('name','c')
+d = graph.addVertex('name','d')
+e = graph.addVertex('name','e')
+a.addEdge('next',b)
+b.addEdge('next',c)
+c.addEdge('next',d)
+d.addEdge('next',e)
+g.withSack(0).V().store("x").repeat(both().simplePath()).emit().path(). <b>(1)</b>
+ group().by(project("a","b").by(limit(local, 1)). <b>(2)</b>
+ by(tail(local, 1))).
+ by(order().by(count(local))). <b>(3)</b>
+ select(values).as("shortestPaths"). <b>(4)</b>
+ select("x").unfold().as("v"). <b>(5)</b>
+ select("shortestPaths"). <b>(6)</b>
+ map(unfold().filter(unfold().where(eq("v"))).count()). <b>(7)</b>
+ sack(sum).sack().as("betweeness"). <b>(8)</b>
+ select("v","betweeness")</pre>
</div>
</div>
<div class="colist arabic">
@@ -1474,16 +1348,15 @@ other reachable vertices in the graph.</
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.withSack(<span class="float">1f</span>).V().repeat(both().simplePath()).emit().path(). <span class="comment">//</span><b>(1)</b>
- group().by(project(<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(limit(local, <span class="integer">1</span>)). <span class="comment">//</span><b>(2)</b>
- by(tail(local, <span class="integer">1</span>))).
- by(order().by(count(local))). <span class="comment">//</span><b>(3)</b>
- select(values).unfold(). <span class="comment">//</span><b>(4)</b>
- project(<span class="string"><span class="delimiter">"</span><span class="content">v</span><span class="delimiter">"</span></span>,<span class="string"><span class="delimiter">"</span><span class="content">length</span><span class="delimiter">"</span></span>).
- by(limit(local, <span class="integer">1</span>)). <span class="comment">//</span><b>(5)</b>
- by(count(local).sack(div).sack()). <span class="comment">//</span><b>(6)</b>
- group().by(select(<span class="string"><span class="delimiter">"</span><span class="content">v</span><span class="delimiter">"</span></span>)).by(select(<span class="string"><span class="delimiter">"</span><span class="content">length</span><span class="delimiter">"</span></span>).sum()) <span class="comment">//</span><b>(7)</b>
-==>[v[<span class="integer">1</span>]:<span class="float">2.1666666666666665</span>,v[<span class="integer">2</span>]:<span class="float">1.6666666666666665</span>,v[<span class="integer">3</span>]:<span class="float">2.1666666666666665</span>,v[<span class="integer">4</span>]:<span class="float">2.1666666666666665</span>,v[<span class="integer">5</span>]:<span class="float">1.6666666666666665</span>,v[<span class="integer">6</span>]:<span class="float">1.6666666666666665</span>]</code></pre>
+<pre>g.withSack(1f).V().repeat(both().simplePath()).emit().path(). <b>(1)</b>
+ group().by(project("a","b").by(limit(local, 1)). <b>(2)</b>
+ by(tail(local, 1))).
+ by(order().by(count(local))). <b>(3)</b>
+ select(values).unfold(). <b>(4)</b>
+ project("v","length").
+ by(limit(local, 1)). <b>(5)</b>
+ by(count(local).sack(div).sack()). <b>(6)</b>
+ group().by(select("v")).by(select("length").sum()) <b>(7)</b></pre>
</div>
</div>
<div class="colist arabic">
@@ -1526,31 +1399,11 @@ give it the highest rank. Consider the f
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> graph.io(graphml()).readGraph(<span class="string"><span class="delimiter">'</span><span class="content">data/grateful-dead.xml</span><span class="delimiter">'</span></span>)
-gremlin> g.V().repeat(groupCount(<span class="string"><span class="delimiter">'</span><span class="content">m</span><span class="delimiter">'</span></span>).by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>).out()).times(<span class="integer">5</span>).cap(<span class="string"><span class="delimiter">'</span><span class="content">m</span><span class="delimiter">'</span></span>). <span class="comment">//</span><b>(1)</b>
- order(local).by(values, decr).limit(local, <span class="integer">10</span>).next() <span class="comment">//</span><b>(2)</b>
-==>PLAYING IN THE BAND=<span class="integer">8758598</span>
-==>ME AND MY UNCLE=<span class="integer">8214246</span>
-==>JACK STRAW=<span class="integer">8173882</span>
-==>EL PASO=<span class="integer">7666994</span>
-==>TRUCKING=<span class="integer">7643494</span>
-==>PROMISED LAND=<span class="integer">7339027</span>
-==>CHINA CAT SUNFLOWER=<span class="integer">7322213</span>
-==>CUMBERLAND BLUES=<span class="integer">6730838</span>
-==>RAMBLE ON ROSE=<span class="integer">6676667</span>
-==>LOOKS LIKE RAIN=<span class="integer">6674121</span>
-gremlin> g.V().repeat(groupCount(<span class="string"><span class="delimiter">'</span><span class="content">m</span><span class="delimiter">'</span></span>).by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>).out().timeLimit(<span class="integer">100</span>)).times(<span class="integer">5</span>).cap(<span class="string"><span class="delimiter">'</span><span class="content">m</span><span class="delimiter">'</span></span>). <span class="comment">//</span><b>(3)</b>
- order(local).by(values, decr).limit(local, <span class="integer">10</span>).next()
-==>PLAYING IN THE BAND=<span class="integer">8758598</span>
-==>ME AND MY UNCLE=<span class="integer">8214246</span>
-==>JACK STRAW=<span class="integer">8173882</span>
-==>EL PASO=<span class="integer">7666994</span>
-==>TRUCKING=<span class="integer">7643494</span>
-==>PROMISED LAND=<span class="integer">7339027</span>
-==>CHINA CAT SUNFLOWER=<span class="integer">7322213</span>
-==>CUMBERLAND BLUES=<span class="integer">6730838</span>
-==>RAMBLE ON ROSE=<span class="integer">6676667</span>
-==>LOOKS LIKE RAIN=<span class="integer">6674121</span></code></pre>
+<pre>graph.io(graphml()).readGraph('data/grateful-dead.xml')
+g.V().repeat(groupCount('m').by('name').out()).times(5).cap('m'). <b>(1)</b>
+ order(local).by(values, decr).limit(local, 10).next() <b>(2)</b>
+g.V().repeat(groupCount('m').by('name').out().timeLimit(100)).times(5).cap('m'). <b>(3)</b>
+ order(local).by(values, decr).limit(local, 10).next()</pre>
</div>
</div>
<div class="colist arabic">
@@ -1586,8 +1439,7 @@ arguments.</p>
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().has(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>).has(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>, gt(<span class="integer">29</span>)).values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
-==>josh</code></pre>
+<pre>g.V().has('name','marko').out('knows').has('age', gt(29)).values('name')</pre>
</div>
</div>
<div class="paragraph">
@@ -1599,10 +1451,8 @@ obvious to any programmer - use a variab
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> marko = g.V().has(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>).next()
-==>v[<span class="integer">1</span>]
-gremlin> g.V(marko).out(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>).has(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>, gt(marko.value(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>))).values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
-==>josh</code></pre>
+<pre>marko = g.V().has('name','marko').next()
+g.V(marko).out('knows').has('age', gt(marko.value('age'))).values('name')</pre>
</div>
</div>
<div class="paragraph">
@@ -1613,11 +1463,10 @@ itself.</p>
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().has(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>).as(<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>). <span class="comment">//</span><b>(1)</b>
- out(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>).as(<span class="string"><span class="delimiter">'</span><span class="content">friend</span><span class="delimiter">'</span></span>). <span class="comment">//</span><b>(2)</b>
- where(<span class="string"><span class="delimiter">'</span><span class="content">friend</span><span class="delimiter">'</span></span>, gt(<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>)).by(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>). <span class="comment">//</span><b>(3)</b>
- values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(4)</b>
-==>josh</code></pre>
+<pre>g.V().has('name','marko').as('marko'). <b>(1)</b>
+ out('knows').as('friend'). <b>(2)</b>
+ where('friend', gt('marko')).by('age'). <b>(3)</b>
+ values('name') <b>(4)</b></pre>
</div>
</div>
<div class="colist arabic">
@@ -1642,11 +1491,9 @@ of one <code>Vertex</code> to another:</
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V().has(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>, <span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>).as(<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>).
- out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).property(<span class="string"><span class="delimiter">'</span><span class="content">creator</span><span class="delimiter">'</span></span>, select(<span class="string"><span class="delimiter">'</span><span class="content">marko</span><span class="delimiter">'</span></span>).by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>))
-==>v[<span class="integer">3</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">marko</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).valueMap()
-==>[<span class="key">creator</span>:[marko],<span class="key">name</span>:[lop],<span class="key">lang</span>:[java]]</code></pre>
+<pre>g.V().has('name', 'marko').as('marko').
+ out('created').property('creator', select('marko').by('name'))
+g.V().has('name', 'marko').out('created').valueMap()</pre>
</div>
</div>
</div>
@@ -1662,18 +1509,11 @@ returned. For instance:</p>
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V(<span class="integer">1</span>)
-==>v[<span class="integer">1</span>]
-gremlin> g.V(<span class="integer">1</span>).out(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>)
-==>v[<span class="integer">2</span>]
-==>v[<span class="integer">4</span>]
-gremlin> g.V(<span class="integer">1</span>).out(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>)
-==>v[<span class="integer">5</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">knows</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).groupCount()
-==>[v[<span class="integer">3</span>]:<span class="integer">1</span>,v[<span class="integer">5</span>]:<span class="integer">1</span>]
-gremlin> g.V(<span class="integer">1</span>).out(<span class="string"><span class="delimiter">'</span><span class="content">knows</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).groupCount().by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
-==>[<span class="key">ripple</span>:<span class="integer">1</span>,<span class="key">lop</span>:<span class="integer">1</span>]</code></pre>
+<pre>g.V(1)
+g.V(1).out('knows')
+g.V(1).out('knows').out('created')
+g.V(1).out('knows').out('created').groupCount()
+g.V(1).out('knows').out('created').groupCount().by('name')</pre>
</div>
</div>
<div class="paragraph">
@@ -1683,9 +1523,8 @@ which will yield cleaner, easier to unde
</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">knows</span><span class="delimiter">'</span></span>).out(<span class="string"><span class="delimiter">'</span><span class="content">created</span><span class="delimiter">'</span></span>).
- groupCount().by(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>)
-==>[<span class="key">ripple</span>:<span class="integer">1</span>,<span class="key">lop</span>:<span class="integer">1</span>]</code></pre>
+<pre>g.V(1).out('knows').out('created').
+ groupCount().by('name')</pre>
</div>
</div>
<div class="paragraph">
@@ -1693,17 +1532,14 @@ which will yield cleaner, easier to unde
</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>).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>
- group().by(<span class="string"><span class="delimiter">'</span><span class="content">lang</span><span class="delimiter">'</span></span>).by(). <span class="comment">//</span><b>(2)</b>
- select(<span class="string"><span class="delimiter">'</span><span class="content">java</span><span class="delimiter">'</span></span>).unfold(). <span class="comment">//</span><b>(3)</b>
- <span class="keyword">in</span>(<span class="string"><span class="delimiter">'</span><span class="content">created</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="comment">//</span><b>(4)</b>
- order(). <span class="comment">//</span><b>(5)</b>
- by(inE().count(),decr). <span class="comment">//</span><b>(6)</b>
- by(<span class="string"><span class="delimiter">'</span><span class="content">age</span><span class="delimiter">'</span></span>,incr).
- dedup().limit(<span class="integer">10</span>).values(<span class="string"><span class="delimiter">'</span><span class="content">name</span><span class="delimiter">'</span></span>) <span class="comment">//</span><b>(7)</b>
-==>josh
-==>marko
-==>peter</code></pre>
+<pre>g.V().out('knows').out('created'). <b>(1)</b>
+ group().by('lang').by(). <b>(2)</b>
+ select('java').unfold(). <b>(3)</b>
+ in('created').hasLabel('person'). <b>(4)</b>
+ order(). <b>(5)</b>
+ by(inE().count(),decr). <b>(6)</b>
+ by('age',incr).
+ dedup().limit(10).values('name') <b>(7)</b></pre>
</div>
</div>
<div class="colist arabic">
@@ -1779,10 +1615,7 @@ on edges where the "weight" property is
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> g.V(<span class="integer">1</span>).outE(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>).has(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>, P.gt(<span class="float">0.5d</span>)).inV().both()
-==>v[<span class="integer">5</span>]
-==>v[<span class="integer">3</span>]
-==>v[<span class="integer">1</span>]</code></pre>
+<pre>g.V(1).outE("knows").has('weight', P.gt(0.5d)).inV().both()</pre>
</div>
</div>
<div class="paragraph">
@@ -1792,11 +1625,8 @@ anonymous traversal allows that to happe
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> weightFilter = outE(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>).has(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>, P.gt(<span class="float">0.5d</span>)).inV();<span class="type">[]</span>
-gremlin> g.V(<span class="integer">1</span>).flatMap(weightFilter).both()
-==>v[<span class="integer">5</span>]
-==>v[<span class="integer">3</span>]
-==>v[<span class="integer">1</span>]</code></pre>
+<pre>weightFilter = outE("knows").has('weight', P.gt(0.5d)).inV();[]
+g.V(1).flatMap(weightFilter).both()</pre>
</div>
</div>
<div class="paragraph">
@@ -1809,17 +1639,10 @@ be to clone the <code>weightFilter</code
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> weightFilter = outE(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>).has(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>, P.gt(<span class="float">0.5d</span>)).inV();<span class="type">[]</span>
-gremlin> g.V(<span class="integer">1</span>).flatMap(weightFilter.clone()).both()
-==>v[<span class="integer">5</span>]
-==>v[<span class="integer">3</span>]
-==>v[<span class="integer">1</span>]
-gremlin> g.V(<span class="integer">1</span>).flatMap(weightFilter.clone()).bothE().otherV()
-==>v[<span class="integer">5</span>]
-==>v[<span class="integer">3</span>]
-==>v[<span class="integer">1</span>]
-gremlin> g.V(<span class="integer">1</span>).flatMap(weightFilter.clone()).groupCount()
-==>[v[<span class="integer">4</span>]:<span class="integer">1</span>]</code></pre>
+<pre>weightFilter = outE("knows").has('weight', P.gt(0.5d)).inV();[]
+g.V(1).flatMap(weightFilter.clone()).both()
+g.V(1).flatMap(weightFilter.clone()).bothE().otherV()
+g.V(1).flatMap(weightFilter.clone()).groupCount()</pre>
</div>
</div>
<div class="paragraph">
@@ -1831,18 +1654,10 @@ the anonymous traversal itself.</p>
</div>
<div class="listingblock">
<div class="content">
-<pre class="CodeRay"><code class="groovy language-groovy">gremlin> weightFilter = { w -> outE(<span class="string"><span class="delimiter">"</span><span class="content">knows</span><span class="delimiter">"</span></span>).has(<span class="string"><span class="delimiter">'</span><span class="content">weight</span><span class="delimiter">'</span></span>, P.gt(w)).inV() }
-==>groovysh_evaluate<span class="error">$</span>_run_closure1<span class="error">@</span><span class="float">77f</span><span class="float">905e3</span>
-gremlin> g.V(<span class="integer">1</span>).flatMap(weightFilter(<span class="float">0.5d</span>)).both()
-==>v[<span class="integer">5</span>]
-==>v[<span class="integer">3</span>]
-==>v[<span class="integer">1</span>]
-gremlin> g.V(<span class="integer">1</span>).flatMap(weightFilter(<span class="float">0.5d</span>)).bothE().otherV()
-==>v[<span class="integer">5</span>]
-==>v[<span class="integer">3</span>]
-==>v[<span class="integer">1</span>]
-gremlin> g.V(<span class="integer">1</span>).flatMap(weightFilter(<span class="float">0.5d</span>)).groupCount()
-==>[v[<span class="integer">4</span>]:<span class="integer">1</span>]</code></pre>
+<pre>weightFilter = { w -> outE("knows").has('weight', P.gt(w)).inV() }
+g.V(1).flatMap(weightFilter(0.5d)).both()
+g.V(1).flatMap(weightFilter(0.5d)).bothE().otherV()
+g.V(1).flatMap(weightFilter(0.5d)).groupCount()</pre>
</div>
</div>
</div>
@@ -1965,7 +1780,7 @@ submissions!</p>
</div>
<div id="footer">
<div id="footer-text">
-Last updated 2016-10-04 11:56:22 -04:00
+Last updated 2016-10-04 18:36:19 +02:00
</div>
</div>
</body>