aggregate - Sparql group_concat-停止订购

我是SPARQL的新手，并且正在经历一些我不理解的有趣行为。

所以我有四个基因:

a-gene
b-gene
c-gene
d-gene

和两个菌株:

strain1
strain2

和以下三元组:

strain1 hasGene a-gene
strain1 hasGene b-gene
strain1 hasGene d-gene

strain2 hasGene b-gene
strain2 hasGene d-gene

我的目标是进行一个SPARQL查询，为所有菌株添加一个值到属性hasBinary中，其中hasBinary是菌株具有和不具有哪些基因的相应二进制文件。
例如:

strain1 hasBinary 1101
strain2 hasBinary 0101

strain1具有基因a-gene，b基因，d-gene，但没有c-gene。
给定查询(注意菌株和基因分别在Strain和Gene类中):

select ?s (group_concat(?result ; separator="") as ?binary)
where { ?g a Gene.
        ?s a Strain.
        optional{?s ?hasGene ?g.}.
        bind((if(bound(?hasGene), "1","0")) as ?result). }
group by ?s
order by ?s

输出为:

strain1 1101
strain2 0101

哪个是正确的。但是当我执行查询时:

construct {?s hasBinary ?binary}
where{

select ?s (group_concat(?result ; separator="") as ?binary)
where { ?g a Gene.
        ?s a Strain.
        optional{?s ?hasGene ?g.}.
        bind((if(bound(?hasGene), "1","0")) as ?result).


      }
group by ?s
order by ?s

}

输出为:

strain1 hasBinary 0111
strain2 hasBinary 0011

这是完全错误的。好像group_concat正在对结果进行排序。我不知道为什么要这样做，如果命令了二进制文件，那就没用了。与这个问题的任何帮助，将不胜感激。

最佳答案

据我所知，您的查询是正确的，并且您观察到的问题是所使用的任何SPARQL引擎中的错误。或者至少:当我在芝麻商店(版本2.8.8)上尝试您的案件时，它给了我预期的结果。

编辑，我得到正确结果的原因是Sesame恰好以预期的顺序返回结果，但是正如@TallTed正确说明的那样，查询实际上并没有强制执行它，因此您不能依靠它。因此，我先前的断言是端点中的错误是错误的。

让我们来探讨一下。

我使用的数据:

@prefix : <http://example.org/> .

:a-gene a :Gene .
:b-gene a :Gene .
:c-gene a :Gene .
:d-gene a :Gene .

:strain1 a :Strain .
:strain2 a :Strain .

:strain1 :hasGene :a-gene .
:strain1 :hasGene :b-gene .
:strain1 :hasGene :d-gene .


:strain2 :hasGene :b-gene .
:strain2 :hasGene :d-gene .

如果我们看一下查询的最简单形式，我们想要返回所有?s和所有?g，对于它们，可选地存在:hasGene关系，并且我们希望它们顺序排列。您最初的查询基本上是这样的:

PREFIX : <http://example.org/>
select ?s ?g
where { ?g a :Gene.
        ?s a :Strain.
        optional { ?s ?hasGene ?g } .
}
order by ?s

现在，此查询在我的芝麻商店(以及您的端点)中返回以下内容:

?s                              ?g
<http://example.org/strain1>    <http://example.org/a-gene>
<http://example.org/strain1>    <http://example.org/b-gene>
<http://example.org/strain1>    <http://example.org/c-gene>
<http://example.org/strain1>    <http://example.org/d-gene>
<http://example.org/strain2>    <http://example.org/a-gene>
<http://example.org/strain2>    <http://example.org/b-gene>
<http://example.org/strain2>    <http://example.org/c-gene>
<http://example.org/strain2>    <http://example.org/d-gene>

看起来不错吧？全部按字母数字顺序。但是重要的是要意识到此处?g列的顺序是巧合的。如果引擎返回了以下代码:

?s                              ?g
<http://example.org/strain1>    <http://example.org/c-gene>
<http://example.org/strain1>    <http://example.org/b-gene>
<http://example.org/strain1>    <http://example.org/a-gene>
<http://example.org/strain1>    <http://example.org/d-gene>
<http://example.org/strain2>    <http://example.org/b-gene>
<http://example.org/strain2>    <http://example.org/a-gene>
<http://example.org/strain2>    <http://example.org/c-gene>
<http://example.org/strain2>    <http://example.org/d-gene>

...这也将是一个有效的结果-毕竟，我们的查询没有任何地方说?g应该排序。

但是，解决方案很简单:在?s和?g上同时订购。因为在我们特定的SPARQL端点中，即使没有此命令，也已经“巧合”地返回了正确的顺序，所以我们可以验证一下它的技巧:使用DESC运算符还原顺序。

查询:

PREFIX : <http://example.org/>
SELECT ?s ?g
WHERE { ?g a :Gene.
        ?s a :Strain.
        OPTIONAL { ?s ?hasGene ?g } .
}
ORDER BY ?s DESC(?g)

结果:

?s                              ?g
<http://example.org/strain1>    <http://example.org/d-gene>
<http://example.org/strain1>    <http://example.org/c-gene>
<http://example.org/strain1>    <http://example.org/b-gene>
<http://example.org/strain1>    <http://example.org/a-gene>
<http://example.org/strain2>    <http://example.org/d-gene>
<http://example.org/strain2>    <http://example.org/c-gene>
<http://example.org/strain2>    <http://example.org/b-gene>
<http://example.org/strain2>    <http://example.org/a-gene>

您可以看到?g列实际上已经按相反的字母顺序排序(这当然是您想要的相反顺序，但是可以通过稍后省略查询的DESC部分来轻松地进行纠正-关键是我们已经验证了这种方式是由我们的查询进行排序，而不是我们使用的端点)。

但是，它仍然不能完全解决二进制字符串中的排序问题。由于在原始查询中BIND发生在排序之前(因为绑定是图形模式的一部分，在结果排序发生之前会得到充分评估)，因此ORDER BY子句对此没有影响。也就是说，如果我们简单地执行以下查询:

PREFIX : <http://example.org/>
SELECT ?s (GROUP_CONCAT(?result ; SEPARATOR="") as ?binary)
WHERE { ?g a :Gene.
        ?s a :Strain.
        OPTIONAL { ?s ?hasGene ?g } .
        BIND((IF(BOUND(?hasGene), "1","0")) AS ?result).
}
GROUP BY ?s
ORDER BY ?s DESC(?g)

我们仍然会得到以下结果:

?s  ?binary
<http://example.org/strain1>    "1101"
<http://example.org/strain2>    "0101"

换句话说，我们的二进制字符串仍然没有被反转。

解决方案是引入另一个子查询，该子查询将所需的结果传递给其外部查询，然后将其排序以创建二进制字符串，如下所示:

PREFIX : <http://example.org/>
SELECT ?s (GROUP_CONCAT(?result ; SEPARATOR="") as ?binary)
WHERE {
  { SELECT ?s ?hasGene
    WHERE { ?g a :Gene.
            ?s a :Strain.
            OPTIONAL {?s ?hasGene ?g.}.
    }
    ORDER BY ?s DESC(?g)
  }
  BIND((IF(BOUND(?hasGene), "1","0")) AS ?result).
}
GROUP BY ?s

结果是:

?s  ?binary
<http://example.org/strain1>    "1011"
<http://example.org/strain2>    "1010"

如您所见，查询现在强制执行了正确的(反向)二进制字符串。然后，我们需要将整个野兽输入到所需的CONSTRUCT查询中，最后我们需要对二进制字符串进行倒置。

完整的查询将变为:

查询2:

PREFIX : <http://example.org/>
CONSTRUCT {?s :hasBinary ?binary }
WHERE {
  SELECT ?s (GROUP_CONCAT(?result ; SEPARATOR="") as ?binary)
  WHERE {
    { SELECT ?s ?hasGene
      WHERE { ?g a :Gene.
              ?s a :Strain.
              OPTIONAL {?s ?hasGene ?g.}.
      }
      ORDER BY ?s ?g
    }
    BIND((IF(BOUND(?hasGene), "1","0")) AS ?result).
  }
  GROUP BY ?s
}

结果:

<http://example.org/strain1> <http://example.org/hasBinary> "1101" .
<http://example.org/strain2> <http://example.org/hasBinary> "0101" .