Rdf 在属性路径中查找所有步骤_Rdf_Sparql

Rdf 在属性路径中查找所有步骤

rdf sparql

Rdf 在属性路径中查找所有步骤,rdf,sparql,Rdf,Sparql,我是SPARQL新手，我正在尝试创建一个属性路径查询，该查询将沿着路径吐出每个中间步骤。到目前为止，我有： select ?object where { <subjectURI> <isRelatedTo>+ ?object . } select？对象在哪里{ +？对象。 } 这为我提供了一个路径中与主题URI的所有关系的列表，无论关系有多遥远（如果到目前为止我错了，请纠正我）但是，我想看看这种关系是如何组织的。比如： <subjectURI> &

我是SPARQL新手，我正在尝试创建一个属性路径查询，该查询将沿着路径吐出每个中间步骤。到目前为止，我有：

select ?object
where {
  <subjectURI> <isRelatedTo>+ ?object .
}

select？对象
在哪里{
+？对象。
}

这为我提供了一个路径中与主题URI的所有关系的列表，无论关系有多遥远（如果到目前为止我错了，请纠正我）

但是，我想看看这种关系是如何组织的。比如：

<subjectURI> <isRelatedTo> <object1>
<object1> <isRelatedTo> <object2>
<object2> <isRelatedTo> <object3>

等等……这可能吗？

不，这是对属性路径设计的限制

路径可以用于压缩更复杂的查询模式，也可以用于测试任意长度的路径，如示例中所示

前者可以转换为一种形式，为您提供中间步骤，例如

SELECT * WHERE
{
  ?s <http://predicate>/<http://predicate> ?o
}

选择*WHERE
{
？s/？o
}

可以转换为以下内容：

SELECT * WHERE
{
  ?s <http://predicate> ?intermediate .
  ?intermediate <http://predicate> ?o .
}

选择*WHERE
{
？s？中间体。
？中间？o。
}

不幸的是，对于任意长度的路径也不能这样做。但是，如果您知道路径的上限是多少，您可以这样重写查询：

SELECT *
WHERE
{
  {
    ?s <http://predicate> ?step1 .
    ?step1 <http://predicate> ?o .
  }
  UNION
  {
    ?s <http://predicate> ?step1 .
    ?step1 <http://predicate> ?step2 .
    ?step2 <http://predicate> ?o .
  }
  # Add additional UNION for each length of path you want up to your upper bound
}

选择*
哪里
{
{
步骤1。
？步骤1？o。
}
联合
{
步骤1。
？步骤1？步骤2。
？步骤2？o。
}
#为每个路径长度添加额外的并集，直到上限
}

尽管您可以立即看到，这会使事情变得非常冗长。

虽然属性路径可以做些什么，但这取决于您的具体需求，您可能可以在这里获得所需的内容。考虑这些数据：

@prefix : <urn:ex:>.

:a :relatedTo :b .
:b :relatedTo :c .
:c :relatedTo :d .

:a :relatedTo :e .
:e :relatedTo :f .
:f :relatedTo :g .

:h :relatedTo :i .
:i :relatedTo :j .
:j :relatedTo :k .
:k :relatedTo :l .

我意识到在你的例子中，你有一个特定的主题，但我们可以概括一下，用这样的查询来询问这些路径中的每一条边：

前缀：
选择*where{
#开辟道路
？开始：与*？midI相关。
筛选器不存在{[]：relatedTo？begin}
#抓住下一个优势
？midI：与？midJ相关。
#走到路的尽头。
？midJ：与*？结束相关。
筛选器不存在{？结束：relatedTo[]}
}
按？开始？结束订购

显示每个

的每个边：与路径相关。您还可以使输出更漂亮一点：
前缀：
选择（concat（str（？begin），“--”，str（？end））作为路径？midI？midJ在哪里{
#开辟道路
？开始：与*？midI相关。
筛选器不存在{[]：relatedTo？begin}
#抓住下一个优势
？midI：与？midJ相关。
#走到路的尽头。
？midJ：与*？结束相关。
筛选器不存在{？结束：relatedTo[]}
}
按路径订购


同样的方法可以让您做一些有趣的事情，比如找出某些节点之间的距离：
前缀：
选择？开始？结束（计数（*）为？长度），其中{
#开辟道路
？开始：与*？midI相关。
筛选器不存在{[]：relatedTo？begin}
#抓住下一个优势
？midI：与？midJ相关。
#走到路的尽头。
？midJ：与*？结束相关。
筛选器不存在{？结束：relatedTo[]}
}
分组方式？开始？结束


在我上面提供的数据中，路径恰好是按字母顺序排列的，因此排序以正确的顺序生成边。但是，即使边缘节点不是按字母顺序排列的，我们仍然可以通过计算它们在列表中的位置来按顺序打印它们。此查询：
前缀：
选择？开始？midI？midJ（计数（？计数器）作为？位置）？结束在哪里{
？开始：与*计数器相关。
？计数器：与*？midI相关。
筛选器不存在{[]：relatedTo？begin}
？midI：与？midJ相关。
？midJ：与*？结束相关。
筛选器不存在{？结束：relatedTo[]}
}
分组依据？开始？结束？midI？midJ


我们不需要查看该计数，但您可以使用它作为排序条件，而不是选择位置：
前缀：
选择？开始？midI？midJ？结束
在哪里{
？开始：与*计数器相关。
？计数器：与*？midI相关。
筛选器不存在{[]：relatedTo？begin}
？midI：与？midJ相关。
？midJ：与*？结束相关。
筛选器不存在{？结束：relatedTo[]}
}
分组依据？开始？结束？midI？midJ
订单开始结束计数（？计数器）

并确保按顺序获得您的边
 谢谢！我想我记得读过关于这个限制的文章。解决方案很详细，但可能比尝试重建跃点后查询要简单。@user2350906虽然对属性路径的操作有一些限制，但我认为您可以从使用属性路径的查询中获得所需的信息，我已在中对其进行了描述。感谢您的回复。您的建议在某种程度上是可行的，但当我添加了多个步骤时，查询没有任何响应。根据这个查询：选择？x（COUNT（？z）作为？linkTotal），其中{x:relatedTo+？z.}按？x分组，其中（COUNT（？x）>1）
我得到的最大值为12。这是否意味着最长最短路径是12个步骤，因此我应该能够在您的查询中添加12个（呃，10？）中间步骤，并且仍然可以得到一个匹配的案例？@user2350906如果没有看到您的数据，很难判断查询将返回什么。但是我注意到，您使用的是+
，我在任何查询中都没有使用它+
表示一个或多个，而*
表示0或多个。@user2350906您能再详细说明一下吗？+
之间的差异是显著的，如果你按照？x
进行分组，那么HAVING
子句应该是HAVING（COUNT（？z）>1）
而不是HAVING COUNT（？x）>1
（即COUNT？z
，而不是？y）吗？@JoshuaTaylor感谢你的回答。我有一个类似的问题。在我的例子中，两个节点之间有多条路径。我想得到从开始到结束节点的所有路径。请帮忙。@DixitSingla我不确定您是否能在SPARQL中方便地做到这一点。您可以获取两个节点之间所有路径的所有边，但是您仍然需要
a --> b --> c --> d
a --> e --> f --> g
h --> i --> j --> k --> l

$ arq --data data.n3 --query query.sparql
-----------------------------
| begin | midI | midJ | end |
=============================
| :a    | :a   | :b   | :d  |
| :a    | :b   | :c   | :d  |
| :a    | :c   | :d   | :d  |
| :a    | :a   | :e   | :g  |
| :a    | :e   | :f   | :g  |
| :a    | :f   | :g   | :g  |
| :h    | :h   | :i   | :l  |
| :h    | :i   | :j   | :l  |
| :h    | :j   | :k   | :l  |
| :h    | :k   | :l   | :l  |
-----------------------------

$ arq --data data.n3 --query query.sparql
--------------------------------------
| path                 | midI | midJ |
======================================
| "urn:ex:a--urn:ex:d" | :a   | :b   |
| "urn:ex:a--urn:ex:d" | :b   | :c   |
| "urn:ex:a--urn:ex:d" | :c   | :d   |
| "urn:ex:a--urn:ex:g" | :a   | :e   |
| "urn:ex:a--urn:ex:g" | :e   | :f   |
| "urn:ex:a--urn:ex:g" | :f   | :g   |
| "urn:ex:h--urn:ex:l" | :h   | :i   |
| "urn:ex:h--urn:ex:l" | :i   | :j   |
| "urn:ex:h--urn:ex:l" | :j   | :k   |
| "urn:ex:h--urn:ex:l" | :k   | :l   |
--------------------------------------

------------------------
| begin | end | length |
========================
| :a    | :g  | 3      |
| :a    | :d  | 3      |
| :h    | :l  | 4      |
------------------------

----------------------------------
| begin | midI | midJ | .1 | end |
==================================
| :a    | :a   | :b   | 1  | :d  |
| :a    | :b   | :c   | 2  | :d  |
| :a    | :c   | :d   | 3  | :d  |
| :a    | :a   | :e   | 1  | :g  |
| :a    | :e   | :f   | 2  | :g  |
| :a    | :f   | :g   | 3  | :g  |
| :h    | :h   | :i   | 1  | :l  |
| :h    | :i   | :j   | 2  | :l  |
| :h    | :j   | :k   | 3  | :l  |
| :h    | :k   | :l   | 4  | :l  |
----------------------------------