Question

我有一个模式

<friend>: uid .
<owns_pet>: uid .
<person.age>: int @index(int) .
<person.name>: string @index(fulltext, term, trigram) .
<pet.name>: string @index(fulltext, term) .

有数据

{
  set {
    _:a1 <person.name> "A1" .
    _:a1 <person.age> "43" .
    _:a2 <person.name> "A2" .
    _:a2 <person.age> "33" .
    _:a3 <person.name> "A3" .
    _:a3 <person.age> "37" .
    _:a1 <friend> _:a2 .
    _:a1 <friend> _:a3 .
    _:a3 <friend> _:a2 .
    _:p2 <pet.name> "P2" .
    _:p3 <pet.name> "P3" .
    _:a2 <owns_pet> _:p2 .
    _:a3 <owns_pet> _:p3 .
  }
}

是否可以创建一个查询，该查询仅返回有朋友的人，并且该朋友的宠物名为“ P3”？我希望看到结果

"result": [
  {
    "name": "A1",
    "age": 43
  }
]

现在我可以查询：

{
  result (func: has(person.name)) @filter(has(friend)) {
    name: person.name
    age: person.age
    friend @filter(has(owns_pet)) {
      owns_pet @filter(eq(pet.name, "P3")) {
      }
    }
  }
}

但这也会返回人“ A3”

Answer 1

找到了一个解决方案，可以返回所需的结果：

{
  var (func: eq(pet.name, "P3")) {
    ~owns_pet {
      ~friend {
        u as uid
      }
    }  
  }

  result (func: uid(u)) {
    name: person.name
    age: person.age
  }
}

但我不知道这是否是正确的方法。

Answer 2

这里是另一个查询，您可以考虑使用@normalize仅返回别名谓词，使用@cascade仅返回包含查询中所有边的结果：

{
  personWithFriendPetP3(func: has(person.name)) @normalize @cascade {
    name: person.name
    age: person.age
    friend {
      owns_pet @filter(eq(pet.name, "P3")) {
        pet.name
      }
    }
  }
}

响应：

{
  "data": {
    "personWithFriendPetP3": [
      {
        "name": "A1",
        "age": 43
      }
    ]
  }
}

鉴于您要在owns_pet和friend的架构类型中设置反向边缘，因此

Your answer会很好用。考虑到它是在根函数中使用索引查询，并且首先对特定的宠物名称进行相等性检查，然后再遍历其他朋友，因此它的工作量将少于上述查询。

此答案中的查询将首先查找在根函数中具有名称的所有人，然后检查其朋友的宠物名称是否为P3。

Dgraph文档：

https://docs.dgraph.io/query-language/#normalize-directive

https://docs.dgraph.io/query-language/#cascade-directive

Dgraph深层过滤

2 个答案: