Gremlin语法入门 #

Gremlin特点：
├── 函数式编程风格
├── 流式数据处理
├── 支持复杂图遍历
├── 多语言驱动支持
└── 可扩展性强

// 基本结构
g.遍历源.遍历步骤1().遍历步骤2()...终端步骤()

// 示例
g.V().hasLabel('person').values('name').limit(10)

遍历步骤分类：
├── 源步骤（Source Steps）
├── 过滤步骤（Filter Steps）
├── 变换步骤（Transform Steps）
├── 侧效步骤（SideEffect Steps）
└── 终端步骤（Terminal Steps）

// 获取所有顶点
g.V()

// 获取指定ID的顶点
g.V('1')
g.V('1', '2', '3')

// 获取指定标签的顶点
g.V().hasLabel('person')

// 获取所有边
g.E()

// 获取指定ID的边
g.E('e1')
g.E('e1', 'e2', 'e3')

// 获取指定标签的边
g.E().hasLabel('knows')

// 注入值
g.inject(1, 2, 3)

// 注入对象
g.inject(['name': 'Tom', 'age': 30])

// 用于批量操作
g.inject(['Tom', 'Jerry', 'Mike']).unfold().addV('person').property('name', identity)

// 精确匹配
g.V().has('name', 'Tom')
g.V().has('name', eq('Tom'))

// 比较操作
g.V().has('age', gt(25))    // 大于
g.V().has('age', gte(25))   // 大于等于
g.V().has('age', lt(40))    // 小于
g.V().has('age', lte(40))   // 小于等于
g.V().has('age', neq(30))   // 不等于

// 区间
g.V().has('age', inside(20, 40))   // 20 < age < 40
g.V().has('age', outside(20, 40))  // age < 20 或 age > 40

// 列表匹配
g.V().has('name', within('Tom', 'Jerry', 'Mike'))
g.V().has('name', without('Tom', 'Jerry'))

// 字符串匹配
g.V().has('name', containing('om'))
g.V().has('name', startingWith('T'))
g.V().has('name', endingWith('m'))
g.V().has('name', regex('T.*m'))

// 单标签
g.V().hasLabel('person')

// 多标签
g.V().hasLabel('person', 'employee')

// 边标签
g.E().hasLabel('knows', 'follows')

// 属性不存在
g.V().hasNot('email')

// 等价于
g.V().not(has('email'))

// 使用filter
g.V().filter(outE().count().is(gt(0)))

// 使用Lambda（注意性能）
g.V().filter { it.get().property('name').orElse('') == 'Tom' }

// 简单条件
g.V().where(outE().count().is(gt(5)))

// 使用标记
g.V().as('a').out('knows').as('b').
  where('a', neq('b'))

// 使用by修饰
g.V().as('a').out('knows').as('b').
  where('a', neq('b')).by('name')

// 简单去重
g.V().out('knows').dedup()

// 按属性去重
g.V().dedup().by('name')

// 按标记去重
g.V().as('a').out('knows').as('b').dedup('a', 'b')

// AND
g.V().and(
  has('age', gt(25)),
  has('name', startingWith('T'))
)

// OR
g.V().or(
  has('name', 'Tom'),
  has('name', 'Jerry')
)

// NOT
g.V().not(has('status', 'inactive'))

// 出边遍历
g.V('1').out()           // 所有出边
g.V('1').out('knows')    // 指定标签出边

// 入边遍历
g.V('1').in()            // 所有入边
g.V('1').in('knows')     // 指定标签入边

// 双向遍历
g.V('1').both()          // 所有边
g.V('1').both('knows')   // 指定标签双向边

// 获取出边
g.V('1').outE()
g.V('1').outE('knows')

// 获取入边
g.V('1').inE()
g.V('1').inE('knows')

// 获取所有边
g.V('1').bothE()

// 从边获取顶点
g.E('e1').inV()   // 入顶点
g.E('e1').outV()  // 出顶点
g.E('e1').bothV() // 两个顶点

// 链式操作
g.V('1').outE().inV()  // 等同于 g.V('1').out()
g.V('1').inE().outV()  // 等同于 g.V('1').in()

// map - 一对一映射
g.V().map(values('name'))
g.V().map(outE().count())

// flatMap - 一对多映射
g.V().flatMap(out('knows'))
g.V().flatMap(values('name', 'email'))

// 选择标记
g.V().as('a').out('knows').as('b').select('a', 'b')

// 选择属性
g.V().as('a').out('knows').as('b').
  select('a', 'b').by('name')

// 选择所有标记
g.V().as('a').out('knows').as('b').select(all)

// 获取路径
g.V('1').out('knows').path()

// 路径属性
g.V('1').out('knows').path().by('name')

// 简单路径（无环）
g.V('1').repeat(out()).times(3).simplePath()

// 获取单个属性值
g.V().values('name')

// 获取多个属性值
g.V().values('name', 'age')

// 获取所有属性值
g.V().values()

// 获取属性映射
g.V().valueMap()

// 获取属性映射（包含ID和标签）
g.V().valueMap(true)

// 计数
g.V().count()

// 条件计数
g.V().has('status', 'active').count()

// 分组计数
g.V().groupCount().by('status')

// 简单分组
g.V().group().by('status')

// 分组聚合
g.V().group().
  by('status').
  by('age', mean())

// 多级分组
g.V().group().
  by('status').
  by(group().by('department'))

// 升序排序
g.V().order().by('name')

// 降序排序
g.V().order().by('name', desc)

// 多属性排序
g.V().order().by('status', asc).by('name', asc)

// 按计算值排序
g.V().order().by(outE().count(), desc)

// 限制数量
g.V().limit(10)

// 跳过前N条
g.V().range(10, 20)  // 第11-20条

// Tail
g.V().order().by('name').tail(10)

// 求和
g.V().values('age').sum()

// 平均值
g.V().values('age').mean()

// 最大值
g.V().values('age').max()

// 最小值
g.V().values('age').min()

// 返回列表
g.V().toList()

// 返回下一个
g.V().next()
g.V().next(5)  // 返回5个

// 执行遍历（不返回结果）
g.addV('person').property('name', 'Tom').iterate()

// 检查是否有结果
g.V().has('name', 'Tom').hasNext()

// 尝试获取下一个（返回Optional）
g.V().has('name', 'Tom').tryNext()

// 添加顶点
g.addV('person').property('name', 'Tom')

// 批量添加
g.addV('person').property('name', 'Tom').
  addV('person').property('name', 'Jerry')

// 添加边
g.addE('knows').from(V('1')).to(V('2'))

// 从遍历添加
g.V('1').addE('knows').to(V('2'))

// 设置属性
g.V('1').property('age', 30)

// 设置多值属性
g.V('1').property(list, 'phone', '123-456-7890')

// 删除顶点
g.V('1').drop()

// 删除边
g.E('e1').drop()

// 删除属性
g.V('1').properties('age').drop()

// 重复N次
g.V('1').repeat(out()).times(3)

// 直到条件
g.V('1').repeat(out()).until(has('name', 'Jerry'))

// 发射中间结果
g.V('1').repeat(out()).emit().times(3)

// 条件发射
g.V('1').repeat(out()).emit(has('status', 'active')).times(3)

// until - 终止条件
g.V('1').repeat(out()).until(outE().count().is(0))

// emit - 发射条件
g.V('1').repeat(out()).emit().until(has('name', 'Jerry'))

// emit在repeat前
g.V('1').emit().repeat(out()).times(3)

// 合并多个遍历
g.V('1').union(
  out('knows'),
  out('follows')
)

// 合并结果
g.V('1').union(
  out('knows'),
  in('knows')
).dedup()

// 返回第一个非空结果
g.V().coalesce(
  values('nickname'),
  values('name'),
  constant('Unknown')
)

// if-else
g.V().choose(
  has('age', gt(30)),
  values('name'),
  constant('Young')
)

// switch-case
g.V().choose(values('status'))
  .option('active', values('name'))
  .option('inactive', constant('Disabled'))
  .option(none, constant('Unknown'))

// 使用标签过滤
g.V().hasLabel('person').has('name', 'Tom')

// 使用limit限制结果
g.V().limit(100)

// 使用索引属性
g.V().has('userId', 'user_001')

// 避免全图扫描
g.V().hasLabel('person')  // 好
g.V()  // 避免

// 查看中间结果
g.V().hasLabel('person').as('persons').
  out('knows').as('friends').
  select('persons', 'friends')

// 计算中间数量
g.V().hasLabel('person').count().as('personCount').
  select('personCount')

// 使用profile分析
g.V().hasLabel('person').out('knows').profile()