学习Gremlin语言

深入学习1:https://blog.csdn.net/linlin1989117/article/details/82558475

V()E()id()label()properties()valueMap()values()

深入学习2:https://blog.csdn.net/linlin1989117/article/details/82658777

out()in()both()outE()inE()bothE()outV()inV()bothV()otherV()

深入学习3:https://blog.csdn.net/linlin1989117/article/details/82589895

hasLabel(labels…​)、hasId(ids…​)、has(key, value)、has(label, key, value)、has(key, predicate)、hasKey(keys…​)、hasValue(values…​)、has(key)、hasNot(key)

深入学习4:https://blog.csdn.net/u010260089/article/details/82594300

count()range()limit()tail()skip()

深入学习5:https://blog.csdn.net/linlin1989117/article/details/82625906

path()simplePath()cyclicPath()

深入学习6:https://blog.csdn.net/javeme/article/details/82760106

repeat()times()until()emit()loops()

深入学习7:https://blog.csdn.net/u010260089/article/details/82666260

order()by()

深入学习8:https://blog.csdn.net/javeme/article/details/82769457

group()groupCount()dedup()by()

深入学习9:https://blog.csdn.net/linlin1989117/article/details/82692587

where()filter()

深入学习10:https://blog.csdn.net/u010260089/article/details/82769959

is()and()or()not()

深入学习11:https://blog.csdn.net/u010260089/article/details/82787808

sum()max()min()mean()

深入学习12:https://blog.csdn.net/linlin1989117/article/details/82849477

math()

深入学习13:https://blog.csdn.net/javeme/article/details/88417208

as()+select()as()+where()as()+match()as()+dedup()

深入学习14:https://blog.csdn.net/linlin1989117/article/details/82703743

choose()branch()

深入学习15:https://blog.csdn.net/u010260089/article/details/82837664

coalesce()optional()union()

深入学习16:https://blog.csdn.net/javeme/article/details/88576363

aggregate()store()unfold()fold()

深入学习17:https://blog.csdn.net/linlin1989117/article/details/82855931

match()

深入学习18:https://blog.csdn.net/u010260089/article/details/82900950

sample()coin()constant()inject()

深入学习19:https://blog.csdn.net/javeme/article/details/89038027

sack()

深入学习20:https://blog.csdn.net/javeme/article/details/89182912

barrier()

深入学习21:https://blog.csdn.net/linlin1989117/article/details/82859866

local()count()max()mean()min()sum()order()tail()limit()range()sample()skip()limit()dedup()

深入学习22:https://blog.csdn.net/u010260089/article/details/82969173

hasNext()next()tryNext()toList()toSet()toBulkSet()fill()iterate()

深入学习23:https://blog.csdn.net/u010260089/article/details/82970917

mapflatMap()

深入学习24:https://blog.csdn.net/javeme/article/details/89184241

sideEffect()

深入学习25:https://blog.csdn.net/linlin1989117/article/details/82859884

profile()explain()

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

深入学习1:

    

g.V()    // 查询图中所有的顶点,注意:g 代表的是整个图(graph),一切查询都是以图开始
g.V('4:Gremlin', '3:TinkerPop') //根据id查询顶点

g.E()    //查询图中所有的边
g.E('S3:TinkerPop>4>>S4:Gremlin')    //根据id查询边

g.V().id()    // 查询所有顶点的id,边类似

g.V().label()    //查询所有顶点的label(标签,类型),边类似

g.V().properties()    //查询所有顶点的属性,边类似
g.V('2:lop').properties().key()    // properties()可以和 key()、value()搭配使用,以获取属性的名称或值。

g.V().properties('lang')    // 查询所有顶点的“lang”属性,如果无“lang”属性的顶点将跳过

g.V().valueMap()    // 查询所有顶点的属性,边类似
//valueMap()与 properties()不同的地方是:它们返回的结构不一样,后者将所有的属性扁平化到一个大列表里面,一个元素代表一个属性;前者保持一个顶点或一条边的属性作为一组,每一组由若干属性的键值对组成。

g.V().values()    //查询所有顶点的属性值,效果等同于:g.V().properties().value()
g.V().values('lang') // 查询所有顶点的“lang”属性,效果等同于:g.V().properties('lang').value()

深入学习2:

g.V().out()    //先查询图中所有的顶点,然后访问顶点的OUT方向邻接点,注意:out()的基准必须是顶点
g.V('3:TinkerPop').out() //id是'3:TinkerPop'的OUT方向邻接点
g.V('3:TinkerPop').out('define') //且限制仅“define”类型的边相连的顶点

g.V('3:TinkerPop').in()  //访问某个顶点的IN方向邻接点
g.V('3:TinkerPop').in('implements') //且限制了关联边的类型

g.V('3:TinkerPop').both()  //访问某个顶点的双向邻接点
g.V('3:TinkerPop').both('implements', 'define')  //且限制了关联边的类型

g.V('3:TinkerPop').outE()  //访问顶点的OUT方向邻接边
g.V('3:TinkerPop').outE('define')  //且限制了关联边的类型

g.V('3:TinkerPop').inE()  //访问某个顶点的IN方向邻接边
g.V('3:TinkerPop').inE('implements')  //且限制了关联边的类型

g.V('3:TinkerPop').bothE()  //访问某个顶点的双向邻接边
g.V('3:TinkerPop').bothE('define', 'implements')  //且限制了关联边的类型

g.V('3:TinkerPop').inE().outV()  //一般情况下,inE().outV()等价于in()
g.V('3:TinkerPop').outE().outV()  //顶点本身,条数按边的数量显示

g.V('3:TinkerPop').outE().inV()  //访问某个顶点的OUT邻接边,取边的入顶点。一般情况下,outE().inV()等价于out()
g.V('3:TinkerPop').inE().inV() //顶点本身,条数按边的数量显示

g.V('3:TinkerPop').outE().bothV() //获取边的双向顶点

g.V('3:TinkerPop').outE().otherV()//获取边的伙伴顶点

//顶点出发 顶点:out(),in(),both() 边:inE(),outE(),bothE()
g.V('2:TinkerPop').out()   //某定点出度的邻顶点
g.V('2:TinkerPop').outE()  //某顶点出度的邻边
g.V('2:TinkerPop').in()    //某顶点入度的邻顶点
g.V('2:TinkerPop').inE()   //某顶点入度的邻边
g.V('2:TinkerPop').both()  //某顶点入度和出度的邻顶点
g.V('2:TinkerPop').bothE() //某顶点入度和出度的邻边
g.V('2:TinkerPop').bothE('define', 'implements') //限制了关联边的类型,inE(),out()等等都可以
//边出发 只有顶点:outV(),inV(),bothV(),otherV()
g.V('2:TinkerPop').inE().outV()   //一般情况下,等价于in()
g.V('2:TinkerPop').outE().outV()  //顶点本身,条数按边的数量显示
g.V('2:TinkerPop').outE().inV()   //一般情况下,等价于out()
g.V('2:TinkerPop').inE().inV()    //顶点本身,条数按边的数量显示
g.V('2:TinkerPop').outE().bothV() //获取边的双向顶点  :本身,以及相邻的顶点
g.V('2:TinkerPop').outE().otherV()//获取边的伙伴顶点  :本身以外的顶点,相当于in(),out()

深入学习3:

// 对‘person’的‘addr’属性建立secondary索引,可以对Text类型property按值进行查询
graph.schema().indexLabel('personByCity').onV('person').by('addr').secondary().ifNotExist().create()
// 对‘person’的‘age’属性建立range索引,可以对Number类型property进行范围查询
graph.schema().indexLabel('personByAge').onV('person').by('age').range().ifNotExist().create()

//hasId(),hasLabel(),has(),hasValue(),hasNot()

g.V().hasLabel('person')  //查询label为"person"的顶点
g.V().hasLabel('person', 'software')  //查询label为"person"或者"software"的顶点

g.V().hasId('zhoney')  //查询id为"zhoney"的顶点
g.V().hasId('zhoney', '3:HugeGraph')  //查询id为“zhoney”或者“3:HugeGraph”的顶点

g.V().has('addr', 'Beijing')  //查询“addr”属性值为“Beijing”的顶点
g.V().has('person', 'addr', 'Beijing')  //查询label为“person”且“addr”属性值为“Beijing”的顶点
g.V().has('age', gt(20))  //查询 年龄>20 的顶点
g.V().has('age') //查询包含属性“age”的顶点,等价于has(key),但0.8.0版本的studio上测试,索引和未索引的字段都查询,结果未通过,报错:Not support query: Query for VERTEX offset=0, limit=9223372036854775807, order by {} where id in [] and [PROPERTIES containskey 3]  目前未找到原因

g.V().hasValue('Beijing') //查询包含属性值“Beijing”的顶点

g.V().hasNot('age') //查询没有属性“age”的顶点

深入学习4:

g.V().count()  //查询图中所有顶点的个数
g.V().hasLabel('person').count() //查询图中类型为“人person”的顶点数
g.V().hasLabel('person').outE('created').count() //查询图中所有的 “人创建created” 的边数
g.V().properties().count() //查询图中所有顶点的属性数

//限定查询返回的元素的范围,上下界表示元素的偏移量,左闭右开。下界以“0”作为第一个元素,上界为“-1”时表示取到最后的元素。
g.V().hasLabel('person').range(0, -1)  //不加限制地查询所有类型为“人person”的顶点
g.V().hasLabel('person').range(2, 5)  //查询类型为“人person”的顶点中的第2个到第5个
g.V().hasLabel('person').range(5, -1) //查询类型为“人person”的顶点中的第5个到最后一个

g.V().limit(2) //查询前两个顶点
g.E().limit(3) //查询前三条边

g.V().tail(2) //查询后两个顶点

g.V().hasLabel('person').skip(5) //0.8.0版本不支持

深入学习5:

// “HugeGraph”顶点到与其有直接关联的顶点的路径(仅包含顶点)
g.V().hasLabel('software').has('name','HugeGraph').both().path() 
//“HugeGraph”顶点到与其有直接关联的顶点的路径(包含顶点和边)
g.V().hasLabel('software').has('name','HugeGraph').bothE().otherV().path() 
//用“name”属性代表person和software顶点
g.V().hasLabel('software').has('name','HugeGraph').bothE().otherV().path().by('name').by('weight') 
//返回所有路径,包含有环路径和无环路径
g.V().hasLabel('software').has('name','HugeGraph').both().both().path() 

// “HugeGraph”顶点到与其有两层关系的顶点的不含环路的路径(只包含顶点)
g.V().hasLabel('software').has('name','HugeGraph').both().both().simplePath().path()

// “HugeGraph”顶点到与其有两层关系的顶点的包含环路的路径(只包含顶点)
g.V().hasLabel('software').has('name','HugeGraph').both().both().cyclicPath().path()

深入学习6:

//可以out(),both(),但没有in()
g.V('okram').repeat(out()).times(1) //访问某个顶点的OUT邻接点(1次)
g.V('okram').repeat(both()).times(2) //访问某个顶点的2度双向邻接点: 访问第1个顶点的所有邻接点(第1层),再访问第1层结果顶点的邻接点(第2层)

//这里用到了path()来获取经过的路径,path的讲解请参考上一期。
//until()与 times()是互斥的,两个语句无法同时存在于同一个循环中。
//until()放在repeat()之前或之后的顺序是会影响逻辑的,放前面表示先判断再执行,放后面表示先执行后判断。
g.V('okram').repeat(out()).until(has('name', 'Gremlin')).path() //查询顶点'okram'到顶点'Gremlin'之间的路径,环的终止条件是遇到名称是'Gremlin'的顶点

//注意:emit()放在repeat()之前或之后的顺序是会影响结果的,放前面表示先收集再执行,放后面表示先执行后收集。
//emit()与times()搭配使用时,是“或”的关系而不是“与”的关系,满足两者间任意一个即可。
g.V('okram').repeat(out()).emit().path()  //查询顶点'okram'的所有OUT可达点的路径
g.V('okram').repeat(out()).emit(hasLabel('person')).path()  //查询顶点'okram'的所有OUT可达点的路径,且必须满足是'person'类型的点
g.V('okram').repeat(out()).times(2).emit(hasLabel('person')).path() //查询顶点'okram'的2度OUT可达点的路径,此外还收集'person'类型的顶点

g.V('okram').repeat(out()).until(loops().is(3)).path() //查询顶点'okram'的3度OUT可达点路径
g.V('okram').repeat(out()).until(has('name', 'Gremlin').and().loops().is(2)).path() //查询顶点'okram'到顶点'Gremlin'之间的路径,且之间只相差2跳的距离,其中的and()是指两个条件都满足

// 查找从一个节点出发,到
// 叶子节点结束的所有路径
// 这些路径的集合为一颗子树(子图)
g.V('okram').repeat(out()).until(outE().count().is(0)).path()

// 已知两个顶点'okram'和'javeme',
// 通过任意关系来找到这两点之间的路径
// 且限制了最大深度为3
// 若存在那么第一条结果即是最短路径
g.V('okram').repeat(bothE().otherV().simplePath()).until(hasId('javeme').and().loops().is(lte(3))).hasId('javeme').path()

深入学习7:

g.V().values('name').order() //以默认(升序)排序输出所有顶点的"name"属性值
g.V().values('name').order().by(incr) //以升序输出所有顶点的"name"属性值
g.V().values('name').order().by(decr) //以降序输出所有顶点的"name"属性值
g.V().values('name').order().by(shuffle) //以随机序输出所有顶点的"name"属性值
g.V().hasLabel('person').order().by('age') //将"person"类型的顶点按照"age"升序(默认)排列输出
g.V().hasLabel('person').order().by('age').values('age')//将"person"类型的顶点按照"age"升序(默认)排列,并获取"age"属性
g.V().hasLabel('person').order().by('age', incr).values('age')//将"person"类型的顶点按照"age"升序排列,并获取"age"属性
g.V().hasLabel('person').order().by('age', decr).values('age')//将"person"类型的顶点按照"age"降序排列输出,并获取"age"属性
g.V().hasLabel('person').order().by('age', shuffle).values('age')//将"person"类型的顶点按照"age"随机序排列输出,并获取"age"属性

深入学习8:

g.V().hasLabel('person').group() //不指定任何维度进行分组
g.V().both().hasLabel('person').group() //不指定任何维度进行分组,重复的元素将会被分为一组
g.V().hasLabel('person').group().by('age')// 根据年龄进行分组
g.V().hasLabel('person').group().by('age').by(count())//根据年龄进行分组,并统计各个年龄的人数
g.V().group().by(label).by(count()) //根据顶点类别进行分组,并统计各个类别的数量

g.V().hasLabel('person').groupCount()//不指定任何维度进行分组计数
g.V().both().hasLabel('person').groupCount()//不指定任何维度进行分组计数,重复的元素将会被分为一组
g.V().hasLabel('person').groupCount().by('age')//根据年龄进行分组计数

g.V().both().hasLabel('person').dedup() //对一组含有重复顶点的数据进行去重
g.V().hasLabel('person').values('age').dedup() //查看所有人当中有哪几种年龄,通过dedup去除掉重复的年龄
g.V().hasLabel('person').dedup().by('age') //从各个年龄的人中选出一个代表

 

 

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页