学习Gremlin语言

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

深入学习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') //从各个年龄的人中选出一个代表