语句 ab().src().dest().depth() 可以查询从一个起点到一个终点的路径，可设置路径长度，支持对起点、终点、所有边、所有中介点进行过滤，可剔除带环路的结果，可限制子查询的结果数量。
语法：
- 语句别名：支持，结构为 PATH
- 全部参数：
| 参数 | 类型 | 规范 | 描述 | 参数别名结构 |
|---|---|---|---|---|
src() |
filter | / | 路径起点的过滤条件；多个点满足条件时会报错 | NODE |
dest() |
filter | / | 路径终点的过滤条件；多个点满足条件时会报错 | NODE |
depth() |
range | >0 | 设置路径的深度 depth(N): N 步 depth(:N): 1~N 步 depth(M:N): M~N 步 depth(N).shortest(<>): N 步内的最短（或最小权重和）路径 |
不支持 |
shortest() |
/ 或 @<schema>.<property> |
数值类的边属性，需 LTE | 不指定边属性时，查询 N 步内最短路径；指定边属性时，查询 N 步内、边属于该 schema、且该属性权重和最小的路径 此时 depth() 参数需填写固定值 |
不支持 |
node_filter() |
filter | / | 中介点（非 src、非 dest）的过滤条件 |
不支持 |
edge_filter() |
filter | / | 所有边的过滤条件 | 不支持 |
path_ascend() |
@<schema>.<property> |
数值、时间类型的边属性，需 LTE | 查找边属于该 schema、且该属性按步递增的路径 | 不支持 |
path_descend() |
@<schema>.<property> |
数值、时间类型的边属性，需 LTE | 查找边属于该 schema、且该属性按步递减的路径 | 不支持 |
direction() |
string | left, right | 规定边的方向 | 不支持 |
no_circle() |
/ | / | 不返回含有环路成分的路径，环路的定义可参见《背景知识》- 常用术语 | 不支持 |
limit() |
int | -1 或 >=0 | 子查询返回的结果数量，-1 表示返回所有结果 | 不支持 |
示例图集：(以下示例将在本图基础上运行)
create().edge_property(@default, "weight", int32)
insert().into(@default).nodes([{_id:"A", _uuid:1}, {_id:"B", _uuid:2}, {_id:"C", _uuid:3}, {_id:"D", _uuid:4}, {_id:"E", _uuid:5}, {_id:"F", _uuid:6}])
insert().into(@default).edges([{_uuid:1, _from_uuid:1, _to_uuid:3, weight:1}, {_uuid:2, _from_uuid:5, _to_uuid:2 , weight:1}, {_uuid:3, _from_uuid:1, _to_uuid:5 , weight:4}, {_uuid:4, _from_uuid:4, _to_uuid:3 , weight:2}, {_uuid:5, _from_uuid:5, _to_uuid:4 , weight:3}, {_uuid:6, _from_uuid:2, _to_uuid:1 , weight:2}, {_uuid:7, _from_uuid:6, _to_uuid:1 , weight:4}])
过滤路径深度
示例：查找从 A 到 E 的 3 步路径，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(3) as p
return p{*}
A --1--> C <--4-- D <--5-- E
示例：查找从 A 到 E 的 1~3 步路径，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3) as p
return p{*}
A --3--> E
A --1--> C <--4-- D <--5-- E
A <--6-- B <--2-- E
示例：查找从 A 到 E 的 2~3 步路径，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(2:3) as p
return p{*}
A --1--> C <--4-- D <--5-- E
A <--6-- B <-2-- E
无权重最短路径
示例：查找从 A 到 E 的 3 步以内的最短路径，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(3)
.shortest() as p
return p{*}
A --3--> E
带权重最短路径
示例：查找从 A 到 E 的 3 步以内的最短路径，以 @default.weight 为权重，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(3)
.shortest(@default.weight) as p
return p{*}
A <--6-- B <--2-- E
分析：边属性 @default.weight 需 LTE
过滤中介点
示例：查找从 A 到 E 的 1~3 步路径，要求不经过点 D，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.node_filter({_id != "D"}) as p
return p{*}
A --3--> E
A <--6-- B <--2-- E
过滤边
示例：查找从 A 到 E 的 1~3 步路径，要求边的 weight 大于 1，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.edge_filter({weight > 1}) as p
return p{*}
A --3--> E
边属性递增、递减
示例：查找从 A 到 E 的 1~3 步路径，要求边的 @default.weight 递增，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.path_ascend(@default.weight) as p
return p{*}
A --3--> E
A --1--> C <--4-- D <--5-- E
分析：边属性 @default.weight 需 LTE
示例：查找从 A 到 E 的 1~3 步路径，要求边的 @default.weight 递减，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.path_descend(@default.weight) as p
return p{*}
A --3--> E
A <--6-- B <--2-- E
分析：边属性 @default.weight 需 LTE
过滤边方向
示例：查找从 A 到 E 的 1~3 步路径，要求边的方向为右，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.direction(right) as p
return p{*}
A --3--> E
示例：查找从 A 到 E 的 1~3 步路径，要求边的方向为左，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.direction(left) as p
return p{*}
A <--6-- B <--2-- E
去除环路
示例：查找从 A 到 C 的 4 步路径，要求剔除带环路的结果，携带全部信息
ab().src({_id == "A"}).dest({_id == "C"}).depth(4).no_circle() as p
return p{*}
A <--6-- B <--2-- E --3--> D --4--> C
分析：如不使用 no_circle()，则返回结果中有环路：
A --3--> E --2--> B --6--> A --1--> C
A <--6-- B <--2-- E --3--> D --4--> C
A <--6-- B <--2-- E <--3-- A --1--> C
limit()
示例：查找 1 条从 A 到 E 的 1~3 步路径，携带全部信息
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3).limit(1) as p
return p{*}
A <--6-- B <--2-- E