比较N-Triples的RDF列表与SPARQL

我试图比较SPARQL中的RDF列表，我有以下turtle文件（以下只是其中的一部分）：

dyldo_o:ob388bc6eb70fae039746174f3092f22 a qb：观察；#一个观察
每种子URI。
：hasSnapshot dyldo_s:s2012-05-13；
：hasSeedURI“http://whatev.er/3" ;
：hasRequestChain(
[http：请求；
http:requestURI“http://whatev.er/3" ;
http:resp dyldo_r:rb388bc6eb70fae0379746174f3092f22
]) .
dyldo_r:rb388bc6eb70fae0379746174f3092f22 a http:响应；
http:statusCodeValue 200；
http:body(
[a rdf：声明；
rdf：受试者；
rdf：谓词；
rdf：对象
#四边形中的上下文等于请求URI
]
[a rdf：声明；
rdf：受试者；
rdf：谓词；
rdf：对象
#四边形中的上下文等于请求URI
]
) .

整个文件包含许多快照，每个快照具有许多不同的URI。 我的SPARQL查询必须能够比较的是http:body，它独立于RDF语句的顺序。它应该找出在具有不同http响应主体的给定快照之后拍摄的快照（是否包含初始快照中没有的三元组）

不幸的是，这一点和其他变化不起作用：

PREFIX : <http://dyldo.info/vocab#> 
PREFIX http: <http://www.w3.org/2011/http#>
PREFIX dyldo: <http://dyldo.info/#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>

select distinct ?seedURI ?subject1
WHERE {
  ?observation1 :hasSnapshot ?snapshot1;
                :hasSeedURI ?seedURI ;
                :hasRequestChain/rdf:rest*/rdf:first ?item1 .
  ?snapshot1 <http://purl.org/dc/terms/created> ?date1 .
  ?item1 http:resp ?hash1 .
  ?hash1 http:body/rdf:rest*/rdf:first ?body1 .
  ?observation2 :hasSnapshot ?snapshot2;
                :hasSeedURI ?seedURI2;
                :hasRequestChain/rdf:rest*/rdf:first ?item2 .
  ?snapshot2 <http://purl.org/dc/terms/created> ?date2 .
  ?item2 http:resp ?hash2 .
  ?hash2 http:body/rdf:rest*/rdf:first ?body2 .
  filter(?date1 = "2012-05-06"^^xsd:date && str(?seedURI) = str(?seedURI2) && ?date2 > ?date1)
  filter (exists {
    ?body1  rdf:subject ?subject1;
            rdf:predicate ?predicate1;
            rdf:object ?object1 .
      filter not exists {
      ?body2 rdf:subject ?subject1;
             rdf:predicate ?predicate1;
             rdf:object ?object1 .
    }
    })
} 

前缀：
前缀http:
前缀dyldo：
前缀rdf：
前缀xsd：
选择不同的？种子URI？主题1
在哪里{
？观察1:hasSnapshot？快照1；
：hasSeedURI？seedURI；
：hasRequestChain/rdf:rest*/rdf:first？项目1。
？快照1？日期1。
？项目1 http:resp？hash1。
？hash1http:body/rdf:rest*/rdf:first？body1。
？观察2:hasSnapshot？快照2；
：hasSeedURI？seedURI2；
：hasRequestChain/rdf:rest*/rdf:first？项目2。
？快照2？日期2。
？项目2 http:resp？hash2。
？hash2http:body/rdf:rest*/rdf:first？body2。
过滤器（？date1=“2012-05-06”^^xsd:date&&str（？seedURI）=str（？seedURI2）和&&date2>？date1）
过滤器（存在）{
？主体1 rdf：受试者？受试者1；
rdf：谓词？谓词1；
对象？对象1。
筛选器不存在{
？主体2 rdf：受试者？受试者1；
rdf：谓词？谓词1；
对象？对象1。
}
})
} 

编辑： 下面的查询似乎很有效，至少在我的示例数据上是这样，也许有更好的方法来实现相同的结果。仍然存在的问题是存在空白节点，如果只有空白节点，则2个相等的RDF内容将被标记为不相等

PREFIX : <http://dyldo.info/vocab#>
PREFIX http: <http://www.w3.org/2011/http#>
PREFIX dyldo: <http://dyldo.info/#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
PREFIX list: <http://jena.hpl.hp.com/ARQ/list#>

select distinct ?seedURI1
WHERE {
?observation1 :hasSnapshot ?snapshot1;
                         :hasSeedURI ?seedURI1 ;
                         :hasRequestChain/rdf:rest* ?rest1 .
?snapshot1 <http://purl.org/dc/terms/created> ?date1 .
?rest1 rdf:first ?requestChain1; rdf:rest rdf:nil .
?requestChain http:resp/http:body ?body1 .
?observation2 :hasSnapshot ?snapshot2;
                  :hasSeedURI ?seedURI2;
                         :hasRequestChain/rdf:rest* ?rest2 .
?snapshot2 <http://purl.org/dc/terms/created> ?date2 .
?rest2 rdf:first ?requestChain2; rdf:rest rdf:nil .
?requestChain http:resp/http:body ?body2 .
filter(?date2 > ?date1 && str(?seedURI1) = str(?seedURI2))
filter (exists {
    ?body1 list:member ?member1 .
    ?member1 rdf:subject ?subject1 .
    ?member1 rdf:object ?object1
    filter not exists {
     ?body2 list:member ?member1 .
     ?member2 rdf:subject ?subject1 .
     ?member2 rdf:object ?object1
            }
}
|| exists {
    ?body2 list:member ?member1 .
     ?member2 rdf:subject ?subject2 .
     ?member2 rdf:object ?object2
    filter not exists {
     ?body1 list:member ?member1 .
     ?member1 rdf:subject ?subject2 .
     ?member1 rdf:object ?object2
            }
    })
}

前缀：
前缀http:
前缀dyldo：
前缀rdf：
前缀xsd：
前缀列表：
选择distinct？seduri1
在哪里{
？观察1:hasSnapshot？快照1；
：hasSeedURI？seedURI1；
：hasRequestChain/rdf:rest*？rest1。
？快照1？日期1。
？rest1 rdf:first？requestChain1；rdf:rest rdf:nil。
？请求链http:resp/http:body？body1。
？观察2:hasSnapshot？快照2；
：hasSeedURI？seedURI2；
：hasRequestChain/rdf:rest*？rest2。
？快照2？日期2。
？rest2 rdf:first？requestChain2；rdf:rest rdf:nil。
？请求链http:resp/http:body？body2。
过滤器（？date2>？date1&&str（？seedURI1）=str（？seedURI2））
过滤器（存在）{
？正文1列表：成员？成员1。
？成员1 rdf：受试者？受试者1。
？成员1 rdf:对象？对象1
筛选器不存在{
？主体2列表：成员？成员1。
？成员2 rdf：受试者？受试者1。
？成员2 rdf:对象？对象1
            }
}
||存在{
？主体2列表：成员？成员1。
？成员2 rdf：受试者？受试者2。
？成员2 rdf:对象？对象2
筛选器不存在{
？正文1列表：成员？成员1。
？成员1 rdf：受试者？受试者2。
？成员1 rdf:对象？对象2
            }
    })
}

您的问题很好，我们知道您完全理解SPARQL。但是，您能否稍微简化示例数据？例如。仅使用文本和空白节点：

：s1:p（1 2 3）。：s2:p（3 2 1）。：s3:p（32[]）：s4:p（[]23）。

等应

（1[]）

和

（1[]）

为“相等”吗？那

（11）

和

（1）

呢？嗨，斯坦尼斯拉夫，谢谢你的回答，说得好，我应该重写我的问题。（1[]）和（1[]）应该是相等的，但它们现在不会相等。你的问题很好，我们知道你完全理解SPARQL。但是，您能否稍微简化示例数据？例如。仅使用文本和空白节点：

：s1:p（1 2 3）。：s2:p（3 2 1）。：s3:p（32[]）：s4:p（[]23）。

等应

（1[]）

和

（1[]）

为“相等”吗？那

（11）

和

（1）

呢？嗨，斯坦尼斯拉夫，谢谢你的回答，说得好，我应该重写我的问题。（1[]）和（1[]）应该相等，但它们现在不相等。

PREFIX : <http://dyldo.info/vocab#>
PREFIX http: <http://www.w3.org/2011/http#>
PREFIX dyldo: <http://dyldo.info/#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
PREFIX list: <http://jena.hpl.hp.com/ARQ/list#>

select distinct ?seedURI1
WHERE {
?observation1 :hasSnapshot ?snapshot1;
                         :hasSeedURI ?seedURI1 ;
                         :hasRequestChain/rdf:rest* ?rest1 .
?snapshot1 <http://purl.org/dc/terms/created> ?date1 .
?rest1 rdf:first ?requestChain1; rdf:rest rdf:nil .
?requestChain http:resp/http:body ?body1 .
?observation2 :hasSnapshot ?snapshot2;
                  :hasSeedURI ?seedURI2;
                         :hasRequestChain/rdf:rest* ?rest2 .
?snapshot2 <http://purl.org/dc/terms/created> ?date2 .
?rest2 rdf:first ?requestChain2; rdf:rest rdf:nil .
?requestChain http:resp/http:body ?body2 .
filter(?date2 > ?date1 && str(?seedURI1) = str(?seedURI2))
filter (exists {
    ?body1 list:member ?member1 .
    ?member1 rdf:subject ?subject1 .
    ?member1 rdf:object ?object1
    filter not exists {
     ?body2 list:member ?member1 .
     ?member2 rdf:subject ?subject1 .
     ?member2 rdf:object ?object1
            }
}
|| exists {
    ?body2 list:member ?member1 .
     ?member2 rdf:subject ?subject2 .
     ?member2 rdf:object ?object2
    filter not exists {
     ?body1 list:member ?member1 .
     ?member1 rdf:subject ?subject2 .
     ?member1 rdf:object ?object2
            }
    })
}