使用OWL和RDF的SPARQL查询中的连接

我想通过Matrix movie查询共享类型最多的电影

PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX dbo: <http://dbpedia.org/ontology/>
PREFIX owl: <http://www.w3.org/2002/07/owl#>

SELECT ?movie_name (count(distinct ?atype) as ?numatype)
FROM <http://dbpedia.org/>
WHERE {

?movie rdf:type dbo:Film;
       rdf:type ?ftype.

dbr:The_Matrix rdf:type ?ttype.

?atype a owl:class;
       owl:intersectionOf [?ftype ?ttype].


?movie rdfs:label ?movie_name.
FILTER (LANG(?movie_name)="en").
}
GROUP BY ?movie_name 
ORDER BY DESC(?numatype)
LIMIT 100

前缀rdf:
前缀rdfs：
前缀dbo：
前缀owl：
选择电影名称（计数（不同的atype）为numatype）
从…起
在哪里{
？电影rdf：类型dbo：电影；
rdf:type？ftype。
dbr：矩阵rdf:type？ttype。
？a型猫头鹰：等级；
owl:f[？ftype？ttype]的交叉。
？电影rdfs：标签？电影名称。
过滤器（LANG（？movie_name）=“en”）。
}
组员？电影名称
按描述排序（？numatype）
限制100

我将？ttype定义为矩阵电影的类型，将？ftype定义为？电影的类型

---

当我在中查询时，没有结果

想法是在类型上使用简单联接：

前缀rdf:
前缀rdfs：
前缀dbo：
选择（样本（？l）作为电影名称）
（将（不同的？t类型）计数为？numSharedTypes）
在哪里{
值？s{dbr:The_矩阵}
这是一种类型。
？电影a dbo：电影；
a？t类型。
过滤器（？电影！=？s）
？电影rdfs：标签？l。
过滤器（LANGMATCHES（LANG（？l），'en'））
}
团体电影
按描述排序（？numSharedTypes）
限制100

连接本身可能很昂贵，因此，您可能会得到一个超时响应。由于演奏家的“任何时候”功能，您将获得一个不完整的结果

看起来查询优化器不够智能，尤其是标签使性能更差。一系列子选择使其速度更快，但在读取查询时更为复杂：

前缀dbo:
前缀rdfs：
前缀rdf：
前缀dbr：
选择？电影名称？numSharedTypes
哪里
{？电影rdfs:标签？l
过滤语言匹配（lang（？l），“en”）
绑定（替换（替换（str（？l），“\\（film\\）$”，“），“[^0-9]*\\sfilm\\）$，”）为电影名称）
{选择电影（计数（？类型）为numSharedTypes）
哪里
{？电影rdf:type dbo:Film；
rdf：类型？类型
{选择？类型
哪里
{dbr:The_矩阵rdf:type？type
}
}
过滤器（？movie！=dbr:The_矩阵）
}
团体电影
按DESC（？numSharedTypes）ASC（？movie）排序
限制100
}
}
按描述（？numSharedTypes）ASC（？电影名称）排序

结果（块）：

+------------------------+----------------+
|电影|名称| numSharedTypes|
+------------------------+----------------+
|矩阵重新加载| 36|
|矩阵旋转| 33|
|矩阵（特许经营权）| 30|
|拆迁人| 28|
|弗里杰克| 28|
|阴谋论| 27|
|深蓝色海洋（1999）| 27|
|公平竞赛（1995）| 27|
|德雷德法官| 27|
|复仇之旅| 27|
|尖叫者（1995）| 27|
|士兵（1998）| 27|
|入侵| 27|
|Timecop | 27|
|总召回量（1990年）| 27|
|V代表仇杀| 27|
|刺客| 26|
| ...                    |            ... |
+------------------------+----------------+

想法是在类型上使用一个简单的联接：

前缀rdf:
前缀rdfs：
前缀dbo：
选择（样本（？l）作为电影名称）
（将（不同的？t类型）计数为？numSharedTypes）
在哪里{
值？s{dbr:The_矩阵}
这是一种类型。
？电影a dbo：电影；
a？t类型。
过滤器（？电影！=？s）
？电影rdfs：标签？l。
过滤器（LANGMATCHES（LANG（？l），'en'））
}
团体电影
按描述排序（？numSharedTypes）
限制100

连接本身可能很昂贵，因此，您可能会得到一个超时响应。由于演奏家的“任何时候”功能，您将获得一个不完整的结果

看起来查询优化器不够智能，尤其是标签使性能更差。一系列子选择使其速度更快，但在读取查询时更为复杂：

前缀dbo:
前缀rdfs：
前缀rdf：
前缀dbr：
选择？电影名称？numSharedTypes
哪里
{？电影rdfs:标签？l
过滤语言匹配（lang（？l），“en”）
绑定（替换（替换（str（？l），“\\（film\\）$”，“），“[^0-9]*\\sfilm\\）$，”）为电影名称）
{选择电影（计数（？类型）为numSharedTypes）
哪里
{？电影rdf:type dbo:Film；
rdf：类型？类型
{选择？类型
哪里
{dbr:The_矩阵rdf:type？type
}
}
过滤器（？movie！=dbr:The_矩阵）
}
团体电影
按DESC（？numSharedTypes）ASC（？movie）排序
限制100
}
}
按描述（？numSharedTypes）ASC（？电影名称）排序

结果（块）：

+------------------------+----------------+
|电影|名称| numSharedTypes|
+------------------------+----------------+
|矩阵重新加载| 36|
|矩阵旋转| 33|
|矩阵（特许经营权）| 30|
|拆迁人| 28|
|弗里杰克| 28|
|阴谋论| 27|
|深蓝色海洋（1999）| 27|
|公平竞赛（1995）| 27|
|德雷德法官| 27|
|复仇之旅| 27|
|尖叫者（1995）| 27|
|士兵（1998）| 27|
|入侵| 27|
|Timecop | 27|
|总召回量（1990年）| 27|
|V代表仇杀| 27|
|刺客| 26|
| ...                    |            ... |
+------------------------+----------------+

方向不对。首先执行子查询，然后使用在子查询中选择的变量执行外部查询。反之亦然。使用

owl:intersectionOf

三重模式，您希望实现什么？SPARQL