Wie wird ein Vertex-Eigenschaftswert in einem TinkerPop-Diagramm erhöht?

Question

Wie würde ich durch ein Diagramm gehen und den Wert einer Vertex-Eigenschaft erhöhen? Entweder um einen bestimmten Betrag oder um einen Betrag in einer Eigenschaft einer Kante, die zu ihm führt.

z. mit der folgenden Grafik:

gremlin> graph = TinkerGraph.open() 
==>tinkergraph[vertices:0 edges:0] 
gremlin> g = graph.traversal() 
==>graphtraversalsource[tinkergraph[vertices:0 edges:0], standard] 
gremlin> a = g.addV('name','a','amount', 100).next() 
==>v[0] 
gremlin> b = g.addV('name','b','amount', 200).next() 
==>v[3] 
gremlin> c = g.addV('name','c','amount', 300).next() 
==>v[6] 
gremlin> a.addEdge('fill', b, 'bonus', 20) 
==>e[9][0-drain->3] 
gremlin> b.addEdge('fill', c, 'bonus', 40) 
==>e[10][3-drain->6] 
gremlin> 

so

1) Wie würde ich jede Ecke von 10 erhöhen?

am Ende möchte ich muss:

gremlin> g.V().valueMap() 
==>[amount:[110],name:[a]] 
==>[amount:[210.0],name:[b]] 
==>[amount:[310.00],name:[c]] 

die Erklärung gegeben:

g.V(a).property('amount', X) 

Ich denke, ich versuche zu tun, so etwas wie:

g.V(a).property('amount', g.V(a).values('amount').next()+10) 

.. .aber für alle Scheitelpunkte in meinem Diagramm. Es sieht aus wie Tinkerpop2 hatte loop() und it.object, die dazu beigetragen haben könnte, scheint aber nicht in Tinkerpop3

Edit: OK, ich bin näher, aber nicht ganz da:

gremlin> g.V().as('x').property('amount', select('x').by('amount')+10) 
No signature of method: org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal.plus() is applicable for argument types: (java.lang.Integer) values: [10] 
Possible solutions: sum(), take(int), sum(groovy.lang.Closure), is(java.lang.Object), use([Ljava.lang.Object;), drop(int) 
Type ':help' or ':h' for help. 
Display stack trace? [yN] 

2) Wie würde ich jede Ecke erhöhen durch den Wert der bonus Eigenschaft in der fill Kante, die dazu führt.

am Ende möchte ich muss:

gremlin> g.V().valueMap() 
==>[amount:[100],name:[a]] 
==>[amount:[220.0],name:[b]] 
==>[amount:[340.00],name:[c]] 

Ich versuchte, ein sack mit, es zu tun, aber es könnte nicht ganz so, wie ein Sack die Daten während des gesamten Traversal ansammelt. Ich habe versucht, die withSack innerhalb der repeat Klausel zu versuchen und einen neuen Sack zu erstellen, aber das hat nicht funktioniert. Ich sehe nicht, wie ich den Wert einer Eigenschaft von einem Scheitelpunkt zu einem Vorgang am nächsten Scheitelpunkt "weitergeben" kann.

Answer 1

Lassen Sie mich TinkerPops Spielzeug-Grafik verwenden, damit andere leichter folgen können. Das Spielzeug Graph enthält 4 Person Eckpunkte, die eine age Eigenschaft haben:

gremlin> g = TinkerFactory.createModern().traversal() 
==>graphtraversalsource[tinkergraph[vertices:6 edges:6], standard] 
gremlin> g.V().has("age").valueMap() 
==>[name:[marko],age:[29]] 
==>[name:[vadas],age:[27]] 
==>[name:[josh],age:[32]] 
==>[name:[peter],age:[35]] 

Um Ihre erste Frage zu beantworten, lassen Sie uns einen konstanten Wert hinzufügen (10):

gremlin> g.V().has("age"). 
      property("age", union(values("age"), constant(10)).sum()).valueMap() 
==>[name:[marko],age:[39]] 
==>[name:[vadas],age:[37]] 
==>[name:[josh],age:[42]] 
==>[name:[peter],age:[45]] 

Eine andere Technik, dies zu tun, ist die Verwendung von sack() s:

gremlin> g.withSack(0).V().has("age"). 
      sack(assign).by("age").sack(sum).by(constant(10)). 
      property("age", sack()).valueMap() 
==>[name:[marko],age:[39]] 
==>[name:[vadas],age:[37]] 
==>[name:[josh],age:[42]] 
==>[name:[peter],age:[45]] 

Nun zu Ihrer zweiten Frage über einen dynamischen Wert Hinzufügen von Vorfall kommt Kanten.Im Spielzeug Diagramm haben wir eine weight Eigenschaft auf jedem Rand, so lasst es uns nutzen:

gremlin> g.V().has("age"). 
      property("age", union(values("age"), bothE().values("weight")).sum()).valueMap() 
==>[name:[marko],age:[30.9]] 
==>[name:[vadas],age:[27.5]] 
==>[name:[josh],age:[34.4]] 
==>[name:[peter],age:[35.2]] 

Und wieder könnte man auch sack() verwenden:

gremlin> g.withSack(0).V().has("age"). 
      sack(assign).by("age").sack(sum).by(bothE().values("weight").sum()). 
      property("age", sack()).valueMap() 
==>[name:[marko],age:[30.9]] 
==>[name:[vadas],age:[27.5]] 
==>[name:[josh],age:[34.4]] 
==>[name:[peter],age:[35.2]] 

So ist die letzte Frage ist: Soll eine Technik bevorzugt über den anderen? Ich würde ja sagen, sack() sollte Ihre Wahl sein - die Traversals sind länger in Bezug auf was Sie eingeben müssen, aber schauen Sie sich die Ausgabe, sack() kann problemlos übertreffen union().