我是 SPARQL 的新手，我正在尝试创建一个属性路径查询，该查询将沿路径输出每个中间步骤。到目前为止，我有这个：
select ?object
where {
<subjectURI> <isRelatedTo>+ ?object .
}
这给了我一个在整个路径中与我的主题 URI 的所有关系的列表，无论这种关系有多远（如果到目前为止我错了，请纠正我）。
但是，我想看看这些关系是如何组织的。比如：
<subjectURI> <isRelatedTo> <object1>
<object1> <isRelatedTo> <object2>
<object2> <isRelatedTo> <object3>
等等……这可能吗？
【问题讨论】：
虽然属性路径中有 some limitations 可以执行的操作，但根据您的具体要求，您可能可以在此处获得所需的内容。考虑这些数据：
@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 .
其中有三个:relatedTo 路径：
a --> b --> c --> d
a --> e --> f --> g
h --> i --> j --> k --> l
我意识到在您的情况下，您有一个特定的主题，但我们可以稍微概括一下，并通过如下查询询问这些路径中的每条路径中的每条边：
prefix : <urn:ex:>
select * where {
# start a path
?begin :relatedTo* ?midI .
FILTER NOT EXISTS { [] :relatedTo ?begin }
# grab next edge
?midI :relatedTo ?midJ .
# get to the end of the path.
?midJ :relatedTo* ?end .
FILTER NOT EXISTS { ?end :relatedTo [] }
}
order by ?start ?end
$ 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 |
-----------------------------
显示每个:relatedTo 路径的每个边缘。你也可以让输出更漂亮一点：
prefix : <urn:ex:>
select (concat(str(?begin),"--",str(?end)) as ?path) ?midI ?midJ where {
# start a path
?begin :relatedTo* ?midI .
FILTER NOT EXISTS { [] :relatedTo ?begin }
# grab next edge
?midI :relatedTo ?midJ .
# get to the end of the path.
?midJ :relatedTo* ?end .
FILTER NOT EXISTS { ?end :relatedTo [] }
}
order by ?path
$ 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 |
--------------------------------------
同样的方法可以让你做一些有趣的事情，比如找出某些节点的距离：
prefix : <urn:ex:>
select ?begin ?end (count(*) as ?length) where {
# start a path
?begin :relatedTo* ?midI .
FILTER NOT EXISTS { [] :relatedTo ?begin }
# grab next edge
?midI :relatedTo ?midJ .
# get to the end of the path.
?midJ :relatedTo* ?end .
FILTER NOT EXISTS { ?end :relatedTo [] }
}
group by ?begin ?end
------------------------
| begin | end | length |
========================
| :a | :g | 3 |
| :a | :d | 3 |
| :h | :l | 4 |
------------------------
在我上面提供的数据中，路径恰好是按字母顺序排列的，因此排序会以正确的顺序产生边缘。但是，即使边缘节点不是按字母顺序排列的，我们仍然可以通过计算它们在列表中的位置来按顺序打印它们。这个查询：
prefix : <urn:ex:>
select ?begin ?midI ?midJ (count(?counter) as ?position) ?end where {
?begin :relatedTo* ?counter .
?counter :relatedTo* ?midI .
FILTER NOT EXISTS { [] :relatedTo ?begin }
?midI :relatedTo ?midJ .
?midJ :relatedTo* ?end .
FILTER NOT EXISTS { ?end :relatedTo [] }
}
group by ?begin ?end ?midI ?midJ
----------------------------------
| 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 |
----------------------------------
我们不需要查看该计数，但您可以将其用作排序条件，而不是选择位置：
prefix : <urn:ex:>
select ?begin ?midI ?midJ ?end
where {
?begin :relatedTo* ?counter .
?counter :relatedTo* ?midI .
FILTER NOT EXISTS { [] :relatedTo ?begin }
?midI :relatedTo ?midJ .
?midJ :relatedTo* ?end .
FILTER NOT EXISTS { ?end :relatedTo [] }
}
group by ?begin ?end ?midI ?midJ
order by ?begin ?end count(?counter)
并保证按顺序获得优势。
【讨论】：
select ?x (COUNT(?z) AS ?linkTotal) where { ?x:relatedTo+ ?z . } group by ?x HAVING (COUNT(?x) > 1) 我得到的最大值为 12。这是否意味着最长的最短路径是 12 步，因此我应该能够在您的查询中添加 12（错误，10？）中间步骤仍然得到一个匹配的案例？
+，我在任何查询中都没有使用它。 + 表示一个或多个，而 * 表示 0 个或多个。
+ 之间的区别很大，如果您按 ?x 分组，那么 HAVING 子句应该是 HAVING (COUNT(?z) > 1) 而不是 HAVING COUNT(?x) > 1)（即计数 ?z，而不是 ?y）？
不，这是属性路径设计的限制。
路径可以用于压缩更复杂的查询模式，也可以用于测试任意长度的路径，如您的示例所示。
前者可以转换为一种形式，为您提供中间步骤，例如
SELECT * WHERE
{
?s <http://predicate>/<http://predicate> ?o
}
可以转换成以下：
SELECT * WHERE
{
?s <http://predicate> ?intermediate .
?intermediate <http://predicate> ?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
}
尽管您可以立即看到这使事情变得非常冗长。
【讨论】：