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/04 19:42:20 UTC
svn commit: r1763321 [2/28] - 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=1763321&r1=1763320&r2=1763321&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 19:42:19 2016
@@ -864,14 +864,23 @@ traversal on the paths found between the
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="colist arabic">
@@ -907,11 +916,20 @@ vertices:</p>
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="paragraph">
@@ -927,46 +945,73 @@ the known person completed an applicatio
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="paragraph">
@@ -990,22 +1035,39 @@ is a simple example that identifies the
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="colist arabic">
@@ -1032,31 +1094,51 @@ but includes a "weight" on the edges, th
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="colist arabic">
@@ -1095,7 +1177,8 @@ structure.</p>
</div>
<div class="listingblock">
<div class="content">
-<pre>g.V().hasLabel('person').groupCount().by('age')</pre>
+<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>
</div>
</div>
<div class="paragraph">
@@ -1106,11 +1189,12 @@ a domain concept such as "young", "old"
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="paragraph">
@@ -1137,11 +1221,12 @@ there is another option to consider with
</div>
<div class="listingblock">
<div class="content">
-<pre>g.V().hasLabel("person").
- groupCount().by(values("age").
- coalesce(is(lt(28)).constant("young"),
- is(lt(30)).constant("old"),
- constant("very old")))</pre>
+<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>
</div>
</div>
<div class="paragraph">
@@ -1161,20 +1246,33 @@ depticted below Gremlin could be use to
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="colist arabic">
@@ -1199,9 +1297,10 @@ arbitrary length over both incoming and
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
</div>
@@ -1222,13 +1321,26 @@ edges associated to each vertex.</p>
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="colist arabic">
@@ -1282,25 +1394,39 @@ graph for demonstration purposes:</p>
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="colist arabic">
@@ -1348,15 +1474,16 @@ other reachable vertices in the graph.</
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="colist arabic">
@@ -1399,11 +1526,31 @@ give it the highest rank. Consider the f
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="colist arabic">
@@ -1439,7 +1586,8 @@ arguments.</p>
</div>
<div class="listingblock">
<div class="content">
-<pre>g.V().has('name','marko').out('knows').has('age', gt(29)).values('name')</pre>
+<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>
</div>
</div>
<div class="paragraph">
@@ -1451,8 +1599,10 @@ obvious to any programmer - use a variab
</div>
<div class="listingblock">
<div class="content">
-<pre>marko = g.V().has('name','marko').next()
-g.V(marko).out('knows').has('age', gt(marko.value('age'))).values('name')</pre>
+<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>
</div>
</div>
<div class="paragraph">
@@ -1463,10 +1613,11 @@ itself.</p>
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="colist arabic">
@@ -1491,9 +1642,11 @@ of one <code>Vertex</code> to another:</
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
</div>
@@ -1509,11 +1662,18 @@ returned. For instance:</p>
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="paragraph">
@@ -1523,8 +1683,9 @@ which will yield cleaner, easier to unde
</div>
<div class="listingblock">
<div class="content">
-<pre>g.V(1).out('knows').out('created').
- groupCount().by('name')</pre>
+<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>
</div>
</div>
<div class="paragraph">
@@ -1532,14 +1693,17 @@ which will yield cleaner, easier to unde
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="colist arabic">
@@ -1615,7 +1779,10 @@ on edges where the "weight" property is
</div>
<div class="listingblock">
<div class="content">
-<pre>g.V(1).outE("knows").has('weight', P.gt(0.5d)).inV().both()</pre>
+<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>
</div>
</div>
<div class="paragraph">
@@ -1625,8 +1792,11 @@ anonymous traversal allows that to happe
</div>
<div class="listingblock">
<div class="content">
-<pre>weightFilter = outE("knows").has('weight', P.gt(0.5d)).inV();[]
-g.V(1).flatMap(weightFilter).both()</pre>
+<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>
</div>
</div>
<div class="paragraph">
@@ -1639,10 +1809,17 @@ be to clone the <code>weightFilter</code
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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>
</div>
</div>
<div class="paragraph">
@@ -1654,10 +1831,18 @@ the anonymous traversal itself.</p>
</div>
<div class="listingblock">
<div class="content">
-<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>
+<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="integer">4976085</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>
</div>
</div>
</div>
@@ -1780,7 +1965,7 @@ submissions!</p>
</div>
<div id="footer">
<div id="footer-text">
-Last updated 2016-10-04 18:36:19 +02:00
+Last updated 2016-10-04 15:39:52 -04:00
</div>
</div>
</body>