所提供的谓词在下表中概述,该步骤将接纳VertexProgram作为参数

至于谓词的注意事项

PFunction<Object,Boolean>花样的谓词。相当于说,给定一些对象,重返true或false。所提供的谓词在下表中概述,并用以各个手续,例如has()where()is()等。
Predicate| Description
–|–
eq(object) | Is the incoming object equal to the provided object?
neq(object)| Is the incoming object not equal to the provided
object?
lt(number)| Is the incoming number less than the provided number?
lte(number)| Is the incoming number less than or equal to the provided
number?
gt(number)| Is the incoming number greater than the provided number?
gte(number)| Is the incoming number greater than or equal to the
provided number?
inside(number,number)| Is the incoming number greater than the first
provided number and less than the second?
outside(number,number)| Is the incoming number less than the first
provided number or greater than the second?
between(number,number)| Is the incoming number greater than or equal
to the first provided number and less than the second?
within(objects…)| Is the incoming object in the array of provided
objects?
without(objects…)| Is the incoming object not in the array of the
provided objects?

除开表中的表达式外,还有诸如not()test()等,如下:

gremlin> not(neq(2)) //1\
==>eq(2)
gremlin> not(within('a','b','c')).test('d') //2\
==>true
gremlin> not(within('a','b','c')).test('a')
==>false

Note
上述谓词表达式来自以下静态引进import static org.apache.tinkerpop.gremlin.process.traversal.P.*.

48 Project Step

project()
步骤(map)将眼下指标投射到由提供的标签键入的Map<String,Object>中。

gremlin> g.V().out('created').
           project('a','b').
             by('name').
             by(__.in('created').count())
==>[a:lop,b:3]
==>[a:lop,b:3]
==>[a:lop,b:3]
==>[a:ripple,b:1]

选拔该手续,能够提供灵活的艺术开始展览遍历的调动。如基于(工程)成立者的食指实行排序,并重临(工程)的名字:

gremlin> g.V().out('created').
           project('a','b').
             by('name').
             by(__.in('created').count()).
           order().by(select('b'),decr).
           select('a')
==>lop
==>lop
==>lop
==>ripple

至于栅栏步骤的注意事项

Gremlin重假设二个懈怠的流处理语言。那代表Gremlin在从遍历起头/尾部获取更加多多少在此之前,会尽其所能地完全处理当下在遍历管道中的任何遍历器。可是,在无数状态下,完全懒惰的持筹握算是不容许的(或不切实际的)。当总计不是懈怠的时候,就存在3个“栅栏步骤”。有三种档次的绊脚石:

  • CollectingBarrierStep
    order(), sample(), aggregate(),
    barrier()等手续。在步骤在此以前的全体遍历器被放入1个汇集中,然后以某种方式(例如有序的)处理,然后将该集合3个2个地“流入(drained)”到下2个手续。

  • ReducingBarrierStep
    fold(), count(), sum(), max(),
    min()等。在步骤此前的有着遍历器都被做“reduce”处理,并且只要拥有原先的遍历器被处理,二个纯净的“reduced后的值(reduced
    value)”遍历器被发送到下一步。

  • SupplyingBarrierStep
    cap()。全部在这些手续在此以前的遍历器被迭代(不处理),然后1些供应商(provided
    supplier)爆发三个单纯的遍历器来继续下一步。

在Gremlin OLAP中,在每一个相邻顶点步骤的末梢能够引进1个栅栏。

49 Program Step

program() – 步骤(map /
sideEffect)是GraphComputer作业的“lambda”步骤。该手续将接纳VertexProgram作为参数,并相应地拍卖传入图形。由此,用户可以成立自个儿的VertexProgram并使其在遍历中实施。

比如,使用PageRankVertexProgram总结PageRank,并降序排列:

gremlin> g = graph.traversal().withComputer()
gremlin> g.V().program(PageRankVertexProgram.build().property('rank').create(graph)).
         order().by('rank', decr).
       valueMap('name', 'rank')
==>[name:[lop],rank:[0.4018125]]
==>[name:[ripple],rank:[0.23181250000000003]]
==>[name:[vadas],rank:[0.19250000000000003]]
==>[name:[josh],rank:[0.19250000000000003]]
==>[name:[marko],rank:[0.15000000000000002]]
==>[name:[peter],rank:[0.15000000000000002]]

Note
开发VertexProgram是大家用户,必要对OLAP有深深钻研。

有关限制的注意事项

限制枚举有多个常量:Scope.local和Scope.global。成效域决定效用域的特定步是与当前指标(本地)相关的,依然整个对象(全局)的满贯对象流。
以下例子:

gremlin> g.V().has('name','marko').out('knows').count() //1\
==>2
gremlin> g.V().has('name','marko').out('knows').fold().count() //2\
==>1
gremlin> g.V().has('name','marko').out('knows').fold().count(local) //3\
==>2
gremlin> g.V().has('name','marko').out('knows').fold().count(global) //4\
==>1

释疑上述例子:
一、马克o知道几个人。
2、马克o的朋友列表被创立,由此,二个指标被计数(即单个列表)。
叁、马克o的爱侣列表被成立,并且本地计数发生该列表中的对象的数据。
4、count(global)count()相同,因为超越1/10半效域步骤的默许行为是大局的。

  • 支撑范围的手续
    count()
    dedup()
    max()
    mean()
    min()
    order()
    range()
    limit()
    sample()
    tail()

50 Properties Step

properties()手续(map)从遍历流中的Element中领取属性。

gremlin> g.V().properties()
==>vp[name->marko]
==>vp[age->29]
==>vp[name->lop]
==>vp[lang->java]
==>vp[name->vadas]
==>vp[age->27]
==>vp[name->josh]
==>vp[age->32]
==>vp[name->ripple]
==>vp[lang->java]
==>vp[name->peter]
==>vp[age->35]

Lambdas的注意事项

Gremlin帮衬Lambda表达式,然而并不引入应用。以下使用Lambda表明式与不用拉姆da表达式举办相同查询的语法相比:

gremlin> g.V().filter{it.get().value('name') == 'marko'}.
               flatMap{it.get().vertices(OUT,'created')}.
               map {it.get().value('name')} // 使用Lambda
==>lop
gremlin> g.V().has('name','marko').out('created').values('name') //不使用Lambda
==>lop

提议用户当且仅当所需功用唯有lambda说明式时,才使用lambda表明式。原因是,lambda不可能被Gremlin的编写翻译策略优化,因为它们不能够被先后检查(参见遍历策略)。

只顾,最近(结束0.2.0版本)还不能够在Gremlin-Server上进行长途发来的lambda,也从未协理远程执行的驱动程序。

51 PropertyMap Step

propertiesMap()– 步骤产生成分属性的Map表示。

gremlin> g.V().propertyMap()
==>[name:[vp[name->marko]],age:[vp[age->29]]]
==>[name:[vp[name->vadas]],age:[vp[age->27]]]
==>[name:[vp[name->lop]],lang:[vp[lang->java]]]
==>[name:[vp[name->josh]],age:[vp[age->32]]]
==>[name:[vp[name->ripple]],lang:[vp[lang->java]]]
==>[name:[vp[name->peter]],age:[vp[age->35]]]

52 Range Step

range()步骤(filter)用于钦点范围。
如再次回到第0/3/陆个极点:

gremlin> g.V().range(0,3) //返回位置在[0,3)即0,1,2的节点
==>v[1]
==>v[3]
==>v[2]

53 Repeat Step

`repeat()·步骤(branch)会基于给定的谓词(predicate)实行巡回遍历。
如以下语句发生相同的结果:

gremlin> g.V(1).out().out().values('name')
==>ripple
==>lop
gremlin> g.V(1).repeat(out()).times(2).values('name')
==>ripple
==>lop
  • 察觉多少个节点之间存在的关联
    从id为一的节点开端向外发现涉及,直至发现name=ripple的节点,输出所遍历路径上节点的名字:

    gremlin> g.V(1).until(has('name','ripple')).repeat(out()).path().by('name')
    ==>[marko,josh,ripple]
    

repeat()有八个调制器:until()emit()

  • until()
    如果until()repeat()而后出现,则是do/while循环。倘诺until()repeat()事先出现,则是while/do循环。
  • emit()
    如果在repeat()此后放置emit(),则对遍历遍历器进行再一次遍历评估。假设将emit()放在repeat()事先,则在进入重复遍历在此以前对遍历器进行求值。

除了emit()地点差别造成的震慑外,emit()还使得repeat()中年老年是循环都会输出。

gremlin>  g.V(1).repeat(out()).times(2).values('name') //两次循环完后的节点
==>ripple
==>lop
gremlin>  g.V(1).repeat(out()).emit().times(2).values('name') //一次循环和两次循环结果都返回
==>lop
==>vadas
==>josh
==>ripple
==>lop
gremlin>  g.V(1).emit().repeat(out()).times(2).values('name') //初始节点1、一次循环和两次循环结果都返回
==>marko
==>lop
==>vadas
==>josh
==>ripple
==>lop

emit()until()能够进入限定,比如:

//从节点1开始按照向外的方向发现节点,直至叶子节点(没有向外发出的边)
gremlin> g.V(1).repeat(out()).until(outE().count().is(0)).path().by('name')
==>[marko,lop]
==>[marko,vadas]
==>[marko,josh,ripple]
==>[marko,josh,lop]
//从节点1开始按照向外的方向发现节点,所有路径上出现的人名字都输出
gremlin> g.V(1).repeat(out()).emit(hasLabel('person')).path().by('name')
==>[marko,vadas]
==>[marko,josh]

54 Sack Step

遍历器能够涵盖名称为“麻袋(sack)”的地点数据结构。
sack()手续用于读取和写入sack(sideEffect或map)。每一个遍历器的种种袋子都会在应用以下语句时创制:
GraphTraversal.withSack(initialValueSupplier,splitOperator?,mergeOperator?).

  • Initial value supplier: 供应商提供每一个横穿袋的起先值。
  • Split operator:
    一个1元操作符克隆(UnaryOperator),它会在遍历器分裂时克隆全体的sack。
  • Merge operator:
    3个贰进制运算符,它会在五个遍历器合并时,统壹它们的sack。

Initial value supplier的例子:

gremlin> g.withSack(1.0f).V().sack()
==>1.0
==>1.0
==>1.0
==>1.0
==>1.0
==>1.0

gremlin> rand = new Random()
==>java.util.Random@4a52178
gremlin> g.withSack {rand.nextFloat()}.V().sack()
==>0.5063787
==>0.1647762
==>0.69914645
==>0.042134523
==>0.18742532
==>0.0388152

下边给出了四个更扑朔迷离的Initial value
supplier示例,当中sack运维值用于运转总计,然后在遍历甘休时打印出来。当某条边被遍历后,边缘权重会乘以sack值:

gremlin>  g.withSack(1.0f).V(1).repeat(outE().sack(mult).by('weight').inV()).times(2).path().sack()
==>1.0
==>0.4

Note
mult来自于静态引入的Operator.mult。
sack()语法还有任何八个可选参数Split operator 和Merge operator。
查看:http://tinkerpop.apache.org/docs/current/reference/#sack-step

55 Sample Step

sample()手续对于在遍历在此之前的1些数据的遍历器进行抽样很有用。

gremlin> g.V().out('knows')
==>v[2]
==>v[4]
gremlin> g.V().out('knows').sample(1)
==>v[2]
gremlin> g.V().out('knows').sample(1)
==>v[4]

56 Select Step

Gremlin数据流处理图形处理的贰个区分在于流程不必然要“前进”,但事实上能够回到此前看来的总括区域。
1般有两种艺术来行使select()步骤(map)。

  • 在途径中挑选标记的步调(在遍历中由as()定义)。
  • Map <String,Object>流(即子地图)中选取对象。
  1. 使用as()在途径中标记

    gremlin> g.V().as('a').out().as('b').out().as('c').select('a','b','c')
    ==>[a:v[1],b:v[4],c:v[5]]
    ==>[a:v[1],b:v[4],c:v[3]]
    
  2. 利用map实行映射

gremlin> g.V().out('created').
           project('a','b').
             by('name').
             by(__.in('created').count()).
           select(`a`)
==>lop
==>lop
==>lop
==>ripple
  • 使用where()展开过滤
    诸如,找出富有体系的联合开发者:

    gremlin> g.V().as('a').out('created').in('created').as('b').select('a','b').by('name') //“共同开发者”包含自己
    ==>[a:marko,b:marko]
    ==>[a:marko,b:josh]
    ==>[a:marko,b:peter]
    ==>[a:josh,b:josh]
    ==>[a:josh,b:marko]
    ==>[a:josh,b:josh]
    ==>[a:josh,b:peter]
    ==>[a:peter,b:marko]
    ==>[a:peter,b:josh]
    ==>[a:peter,b:peter]
    gremlin> g.V().as('a').out('created').in('created').as('b').select('a','b').by('name').where('a',neq('b')) //“共同开发者”排除自己
    ==>[a:marko,b:josh]
    ==>[a:marko,b:peter]
    ==>[a:josh,b:marko]
    ==>[a:josh,b:peter]
    ==>[a:peter,b:marko]
    ==>[a:peter,b:josh]
    

57 SimplePath Step

当遍历时不想博得循环的途径,那么使用simplePath();当想取得循环路径,则动用cyclicPath()。若不内定,则赶回全体路子。

gremlin> g.V(1).both().both().path() //所有路径
==>[v[1],v[3],v[1]]
==>[v[1],v[3],v[4]]
==>[v[1],v[3],v[6]]
==>[v[1],v[2],v[1]]
==>[v[1],v[4],v[5]]
==>[v[1],v[4],v[3]]
==>[v[1],v[4],v[1]]
gremlin> g.V(1).both().both().simplePath().path() //非重复路径
==>[v[1],v[3],v[4]]
==>[v[1],v[3],v[6]]
==>[v[1],v[4],v[5]]
==>[v[1],v[4],v[3]]
gremlin> g.V(1).both().both().cyclicPath().path() //重复路径
==>[v[1],v[3],v[1]]
==>[v[1],v[2],v[1]]
==>[v[1],v[4],v[1]]

58 Skip Step

gremlin> g.V().values('age').order()
==>27
==>29
==>32
==>35
gremlin> g.V().values('age').order().skip(2)
==>32
==>35
gremlin> g.V().values('age').order().range(2, -1)
==>32
==>35

59 Store Step

gremlin> g.V().aggregate('x').limit(1).cap('x')
==>[v[1],v[2],v[3],v[4],v[5],v[6]]
gremlin> g.V().store('x').limit(1).cap('x')
==>[v[1],v[2]]

有意思的是,就算limit()分选是对准一个指标,store()也有七个结果。官网解释为“Realize
that when the second object is on its way to the range() filter (i.e.
[0..1]), it passes through store() and thus, stored before filtered.”

60 Subgraph Step

subgraph()手续(sideEffect)提供了从遍历生成边导出子图(Edge-Induced
Subgraph
)。
以下示例演示怎么着变迁由边“knows”导出的子图:

gremlin> subGraph = g.E().hasLabel('knows').subgraph('subGraph').cap('subGraph').next() //1
==>tinkergraph[vertices:3 edges:2]
gremlin> sg = subGraph.traversal()
==>graphtraversalsource[tinkergraph[vertices:3 edges:2], standard]
gremlin> sg.E() //2
==>e[7][1-knows->2]
==>e[8][1-knows->4]

1:subgraph()急需在边步骤操作后调用;
贰:子图中只含有“knows”的边。

更常见的子图用例是获得围绕单个顶点的全体图形结构.
比如说,从巅峰3上马,依照入射边的矛头逆行二次,将结果壹切输出到子图中:

gremlin> subGraph = g.V(3).repeat(__.inE().subgraph('subGraph').outV()).times(1).cap('subGraph').next()
==>tinkergraph[vertices:4 edges:3]
gremlin> sg = subGraph.traversal()
==>graphtraversalsource[tinkergraph[vertices:4 edges:3], standard]
gremlin> sg.E()
==>e[9][1-created->3]
==>e[11][4-created->3]
==>e[12][6-created->3]

能够记挂上述例子中,逆行贰步的结果:

gremlin> subGraph = g.V(3).repeat(__.inE().subgraph('subGraph').outV()).times(2).cap('subGraph').next()
==>tinkergraph[vertices:4 edges:4]
gremlin> sg = subGraph.traversal()
==>graphtraversalsource[tinkergraph[vertices:4 edges:4], standard]
gremlin> sg.E()
==>e[8][1-knows->4]
==>e[9][1-created->3]
==>e[11][4-created->3]
==>e[12][6-created->3]

随着缅怀,逆行三步的结果,在Modern图的景色中,结果是或不是与逆行2步一样?其实结果是一律的。

61 Sum Step

sum()步骤(map)示例:

gremlin>  g.V().values('age')
==>29
==>27
==>32
==>35
gremlin>  g.V().values('age').sum()
==>123

62 Tail Step

tail()步骤,用于从后面部分起先获得成分。示例如下:

gremlin>  g.V().values('age').order()
==>27
==>29
==>32
==>35
gremlin>  g.V().values('age').order().tail()
==>35
gremlin>  g.V().values('age').order().tail(2)
==>32
==>35

tail()步骤协助Scope.local参数,如下:

gremlin> g.V().valueMap()
==>[name:[marko],age:[29]]
==>[name:[vadas],age:[27]]
==>[name:[lop],lang:[java]]
==>[name:[josh],age:[32]]
==>[name:[ripple],lang:[java]]
==>[name:[peter],age:[35]]
gremlin> g.V().valueMap().tail(local,1)
==>[age:[29]]
==>[age:[27]]
==>[lang:[java]]
==>[age:[32]]
==>[lang:[java]]
==>[age:[35]]

63 TimeLimit Step

莫不希望遍历执行不超越贰微秒。在那种情形下,能够使用timeLimit()步骤(filter)。

64 To Step

to()
步骤不是一个实际上的手续,而是1个看似于as()by()的“步骤调制器”。若是贰个步骤能够承受遍历或字符串,那么to()是丰裕它们的招数。

支持to()的手续包罗:
simplePath()
cyclicPath()
path()
addE()

示例:

gremlin> g.addV().property(id, "101").as("a").
           addV().property(id, "102").as("b").
           addV().property(id, "103").as("c").
           addV().property(id, "104").as("d").
           addE("link").from("a").to("b").
           addE("link").from("b").to("c").
           addE("link").from("c").to("d").iterate()
gremlin> g.V('101').repeat(both().simplePath()).times(3).path()
==>[v[101],v[102],v[103],v[104]]

65 Tree Step

从其它三个要素(即顶点或边),能够凑合来自该因素的爆发路径以形成树。
Gremlin为那种景观提供了tree()步骤(sideEffect)。
图片 1

gremlin> tree = g.V().out().out().tree().next()
==>v[1]={v[4]={v[3]={}, v[5]={}}}
  • 收获树后举行深度遍历

    gremlin> tree = g.V().out().out().tree().next()
    ==>v[1]={v[4]={v[3]={}, v[5]={}}}
    gremlin> tree.getObjectsAtDepth(3)
    ==>v[3]
    ==>v[5]
    

66 Unfold Step

假若达到unfold()(flatMap)的指标是三个迭代器,可迭代或映射,那么它将被开始展览成3个线性格局。

gremlin> g.V(1).out().fold()
==>[v[3],v[2],v[4]]
gremlin> g.V(1).out().fold().unfold()
==>v[3]
==>v[2]
==>v[4]

67 Union Step

union()
步骤(branch)协理合并任意数量的遍历的结果。当遍历器达到union()
步骤时,它被复制到其每一个内部步骤。
图片 2

gremlin> g.V(4).union(
                  __.in().values('age'),
                  out().values('lang'))
==>29
==>java
==>java
gremlin> g.V(4).union(
                  __.in().values('age'),
                  out().values('lang')).path()
==>[v[4],v[1],29]
==>[v[4],v[5],java]
==>[v[4],v[3],java]

68 Value Step

value()手续(map)取三个Property并从中提取该值。

gremlin> g.V(1).properties().value()

69 ValueMap Step

valueMap() 步骤生成成分属性的Map表示。

gremlin> g.V().valueMap()
==>[name:[marko],age:[29]]
==>[name:[vadas],age:[27]]
==>[name:[lop],lang:[java]]
==>[name:[josh],age:[32]]
==>[name:[ripple],lang:[java]]
==>[name:[peter],age:[35]]

要害的是小心,顶点的地图维护每种键的值列表。边或终点属性的映照表示单个属性(不是列表)。原因是TinkerPop3中的顶点会利用每一个键帮忙多少个值的顶峰属性(VertexProperty)。

借使须求该因素的id,label,key和value,则boolean会将其插入到再次来到的照耀中:

gremlin> g.V().hasLabel('person').valueMap(true)
==>[name:[marko],id:1,location:[san diego,santa cruz,brussels,santa fe],label:person]
==>[name:[stephen],id:7,location:[centreville,dulles,purcellville],label:person]
==>[name:[matthias],id:8,location:[bremen,baltimore,oakland,seattle],label:person]
==>[name:[daniel],id:9,location:[spremberg,kaiserslautern,aachen],label:person]

来源: http://tinkerpop.apache.org/docs/current/reference/#union-step

70 Values Step

values()步骤(map)从遍历流中的成分中提取属性的值。

gremlin> g.V(1).values()
==>marko
==>san diego
==>santa cruz
==>brussels
==>santa fe
gremlin> g.V(1).values('location')
==>san diego
==>santa cruz
==>brussels
==>santa fe

71 Vertex Steps

终点步骤(flatMap)是Gremlin语言的底子。通过这几个手续,它恐怕在图纸上“移动”

  • 即遍历。
    图片 3

out(string…):移动到给定边标签的出站的隔壁顶点。
in(string…):移动到给定边标签的扩散的隔壁顶点。
both(string…):移动到给定边标签的传遍和散布的隔壁顶点。
outE(string…):移动到给定边标签的出站事件边。
inE(string…):移动到给定边标签的入站事件边。
bothE(string…):移动到给定边标签的入站和出站事件边。
outV():移动到传播的巅峰。
inV():移动到传播的顶峰。
bothV():移动到四个终端。
otherV():移动到不是从中移出的终点的终点。

Note
out/in/both等独立单词的巅峰步骤,由定点调用;
outE/inE等涉嫌边的极限步骤,由确定地点调用;
outV/inV/bothV/otherV等步骤,由边调用;

72 Where Step

where()手续(filter)遵照指标自我(Scope.local)或对象(Scope.global)的途径历史来过滤当前目的。该手续经常与match()select()组合使用,但能够独立行使。
如获得节点一的同盟方,去除节点1自己:

gremlin> g.V(1).as('a').out('created').in('created').where(neq('a'))\
==>v[4]
==>v[6]

多少个非凡的例子:

gremlin> g.V().where(out('created')).values('name') //1\
==>marko
==>josh
==>peter
gremlin> g.V().out('knows').where(out('created')).values('name') //2\
==>josh
gremlin> g.V().where(out('created').count().is(gte(2))).values('name') //3\
==>josh
gremlin> g.V().where(out('knows').where(out('created'))).values('name') //4\
==>marko
gremlin> g.V().where(__.not(out('created'))).where(__.in('knows')).values('name') //5\
==>vadas
gremlin> g.V().where(__.not(out('created')).and().in('knows')).values('name') //6\
==>vadas
gremlin> g.V().as('a').out('knows').as('b').
           where('a',gt('b')).
             by('age').
           select('a','b').
             by('name') //7\
==>[a:marko,b:vadas]
gremlin> g.V().as('a').out('knows').as('b').
           where('a',gt('b').or(eq('b'))).
             by('age').
             by('age').
             by(__.in('knows').values('age')).
           select('a','b').
             by('name') //8\
==>[a:marko,b:vadas]
==>[a:marko,b:josh]

1、创建项指标人的名字是何等?
贰、被人熟谙,且创造了一个品种的人的名字是哪些?
叁、创制了五个或八个品类的人的名字是怎么?
肆、那3个知道有人创制了2个品种的人的名字是什么?
5、未有创制任李新发西但被某人知道的人的名字是如何?
6、where()步骤的连年与三个单壹的where()加and子句的相果相同。
7、marko知道josh和vadas,但是比vadas老了。
8、marko比josh小,可是知道josh的人与marko年龄相等(就是marko)。