CN108090179A - 一种Spark并发子图查询的方法 - Google Patents

Abstract

本发明公开了一种Spark并发子图查询的方法，包括生成查询图的查询计划、数据图数据预处理、从查询计划中取第一个查询子图，计算匹配实例和匹配点集、依次从查询计划中取下一个查询子图，计算该查询子图的匹配实例和匹配点集，将其与之前的匹配结果合并、查询计划执行完成后输出最终的匹配结果。本发明提供一种Spark并发子图查询的方法，通过当前的子图匹配算法，适用于Spark平台，效率比较高，能使用多台机器并行处理，能力较强，容易处理大规模数据。

Description

一种Spark并发子图查询的方法

技术领域

本发明涉及查询方法技术领域，尤其涉及一种Spark并发子图查询的方法。

背景技术

知识图谱与图数据挖掘中经常需要挖掘满足给定结构的所有子图，这个问题通常称之为子图同构、子图匹配或子图查询。当前的子图匹配算法多是基于单机的，效率比较低，不能使用多台机器并行处理，能力有限，难以处理大规模数据。

发明内容

本发明的目的就在于为了解决上述问题而提供一种Spark并发子图查询的方法。

本发明通过以下技术方案来实现上述目的：

本发明包括以下步骤：

S1：生成查询图的查询计划，将其拆分成多个查询子图，每个查询子图包含1条或多条边，所有的边包含一个公共的顶点；

S2：数据图数据预处理，原始数据图给出了每个顶点和边的属性值，查询子图中给出了顶点和边的匹配函数，预处理过程中先判断数据图中每个顶点与查询子图中哪些顶点匹配，数据图中的每条边与查询子图中哪些边匹配；

S3：从查询计划中取第一个查询子图，计算匹配实例和匹配点集；

S4：依次从查询计划中取下一个查询子图，计算该查询子图的匹配实例和匹配点集，将其与之前的匹配结果合并；

S5：查询计划执行完成后输出最终的匹配结果。

本发明优选地，根据步骤S1，所述查询图拆分包括以下步骤：

A1：取度数最大的顶点作为查询子图的根节点，所有与根节点相连的边与点构成一个新的查询子图，度数最大的顶点存在多个时可随机选一个；

A2：从查询图删除相应的边，边删除后如果存在孤立的顶点也删除，按步骤A1的方式生成新的查询子图；

A3：如果此查询子图与之前生成的查询子图的顶点有交集，则此查询子图是合法的，否则排除此查询子图的根节点，按步骤A1的方式生成新的查询子图，直到生成满足条件的查询子图；

A4：当所有边都属于某个查询子图时终止。

本发明优选地，所述度数为连接的边的数量。

本发明优选地，根据步骤S2，

所述顶点匹配判定用一个BitSet来记录数据图中的顶点匹配哪些查询图中的顶点，假设查询图中顶点的数量为numQv，spark并行匹配方法为：

val graphVertexMatch = dataGraph.mapVertices((_, vd) => { val bitSet =new BitSet(numQv) checkVertexMatch(bitSet) bitSet})

图graphVertexMatch中每个顶点的属性记录该顶点与查询图中的哪些顶点匹配；

所述边匹配判定，一条边匹配查询图中的边需同时满足边的属性匹配以及两端顶点属性匹配，得到顶点属性匹配结果后，判定数据图中的每条边与查询图中的哪些边匹配，假设查询图中边的数量为numQe ,spark并行匹配方法为：

val graphTriplets = graphVertexMatch mapEdges(e => { val bitSet = newBitSet(numQe) checkEdgeMatch(bitSet) bitSet}) triplets map(et => matchTriplet(et)) filter(et => et.attr.size > 0)

其中matchTriplet 为边的3元组匹配方法，假设查询图第i条边的起始点为srci，目标点为dsti：

若考虑边的方向，et满足查询图第i条边的条件为：

et的边属性满足i，且j的起始点匹配srci，目标点匹配dsti；

若不考虑边的方向，匹配条件为：

et的边属性满足i，且et的起始点匹配srci，目标点匹配dsti，或et的目标点匹配srci，起始点匹配dsti；

判定边的匹配后可从结果中过滤掉与查询图任何边都不匹配的边，如上述匹配方法中的最后一行：

filter(et => et.attr.size > 0)

过滤后的结果graphTriplets（3元组）作为后续计算的输入。

本发明优选地，根据步骤S3假设查询子图的根节点为sqRoot, 所有边为sqEdges，则查询子图的匹配过程如下：

检查graphTriplets中每条边与sqEdges的匹配情况，输出满足条件的边，并以满足sqRoot的那个顶点的id作为key，同时记录对端顶点id以及满足的边，如下：

val edgeMatch = graphTriplets flatMap { et => //res结果内容分别为：root点，对端点， 以及满足的边 val res = new ArrayBuffer[(Long, (Long, BitSet))]()matchEdge(res, et, sqRoot, sqEdges) res.toIterator}

将相同key的数据汇集在一起并检查对端顶点的匹配情况，输出匹配的结果：

val instance = edgeMatch.groupByKey()

flatMap(x => matchInstance(x._1, x._2.toArray, sqEdges))

matchInstance中，查询子图的每个叶子节点需有对应的匹配实例，如果某个叶子节点存在多个匹配实例，则输出组合结果；

instance中第一个实例id对应的匹配结果为查询子图的根节点，其他实例id按查询子图的叶子节点的顺序排序，如上述实例匹配的顶点依次是v1, v2, v3, v4。

本发明优选地，根据步骤S4，对应2个查询子图的匹配结果，假设查询子图一的匹配实例为instance1,匹配的顶点为queriedVert1; 查询子图二的匹配实例为instance2,匹配的顶点为queriedVert2；

顶点集的合并方法为：

计算queriedVert1和queriedVert2的交集：

val keyVert = queriedVert1.intersect(queriedVert2)

分别计算queriedVert1和queriedVert2与交集的差集：

val valueVert1 = queriedVert1.diff(keyVert) val valueVert2 =queriedVert2.diff(keyVert)

最终的匹配顶点的集合为3个集合的有序合并：

val resultVert = keyVert ++ valueVert1 ++ valueVert2；

匹配方法为：

将instance1每个记录按keyVert和valueVert1 拆分成对应的2部分

val splitInst1 = instance1.map(recorder => splitRecorder(keyVert))

将instance2每个记录按keyVert和valueVert2 拆分成对应的2部分

val splitInst1 = instance2.map(recorder => splitRecorder(keyVert))

将拆分后的2个实例集按keyVert部分的值做关联，将相同keyVert值的valueVert值关联在一起，并检查合并后的匹配情况，对于每个keyVert，对应的valueVert1和valueVert2均需要有值存在，如果存在多组值，则输出组合结果；

val instance = splitInst1.cogroup(splitInst1)

flatMap{ case (key, (valueVert1, valueVert2)) =>

mergeValue(key, valueVert1, valueVert2)}。

本发明的有益效果在于：

本发明提供一种Spark并发子图查询的方法，通过当前的子图匹配算法，适用于Spark平台，效率比较高，能使用多台机器并行处理，能力较强，容易处理大规模数据。

附图说明

图1是本发明所述一种Spark并发子图查询的方法的查询图；

图2是图1的第一查询子图；

图3是图1的第二查询子图；

图4是图1的第三查询子图；

图5是图1的第四查询子图；

图6是图1中度数为7的查询子图。

具体实施方式

下面结合附图对本发明作进一步说明：

本发明包括以下步骤：

S1：生成查询图的查询计划，将其拆分成多个查询子图，每个查询子图包含1条或多条边，所有的边包含一个公共的顶点；

所述查询图拆分包括以下步骤：

A1：取度数最大的顶点作为查询子图的根节点，所有与根节点相连的边与点构成一个新的查询子图，度数最大的顶点存在多个时可随机选一个，所述度数为连接的边的数量；

A2：从查询图删除相应的边，边删除后如果存在孤立的顶点也删除，按步骤A1的方式生成新的查询子图；

A3：如果此查询子图与之前生成的查询子图的顶点有交集，则此查询子图是合法的，否则排除此查询子图的根节点，按步骤A1的方式生成新的查询子图，直到生成满足条件的查询子图；

A4：当所有边都属于某个查询子图时终止；

例如对于下图1所示的查询图，v1、v3的度数最大，都为3，假设选取v1为第一个查询子图的根节点，则第一个查询子图如图2所示。从查询图中删除相应的点和边后，剩余的查询图如图3所示，同理可生成图4所示的查询子图。剩余的查询图如图5所示，度数最大的点为v7，选其作为根节点，生成的查询子图如图6所示。至此查询计划已经生成，包含3个查询子图；

S2：数据图数据预处理，原始数据图给出了每个顶点和边的属性值，查询子图中给出了顶点和边的匹配函数，预处理过程中先判断数据图中每个顶点与查询子图中哪些顶点匹配，数据图中的每条边与查询子图中哪些边匹配；

所述顶点匹配判定用一个BitSet来记录数据图中的顶点匹配哪些查询图中的顶点，假设查询图中顶点的数量为numQv，spark并行匹配方法为：

val graphVertexMatch = dataGraph.mapVertices((_, vd) => { val bitSet =new BitSet(numQv) checkVertexMatch(bitSet) bitSet})

图graphVertexMatch中每个顶点的属性记录该顶点与查询图中的哪些顶点匹配；

所述边匹配判定，一条边匹配查询图中的边需同时满足边的属性匹配以及两端顶点属性匹配，得到顶点属性匹配结果后，判定数据图中的每条边与查询图中的哪些边匹配，假设查询图中边的数量为numQe ,spark并行匹配方法为：

val graphTriplets = graphVertexMatch mapEdges(e => { val bitSet = newBitSet(numQe) checkEdgeMatch(bitSet) bitSet}) triplets map(et => matchTriplet(et)) filter(et => et.attr.size > 0)

其中matchTriplet 为边的3元组匹配方法，假设查询图第i条边的起始点为srci，目标点为dsti：

若考虑边的方向，et满足查询图第i条边的条件为：

et的边属性满足i，且j的起始点匹配srci，目标点匹配dsti；

若不考虑边的方向，匹配条件为：

et的边属性满足i，且et的起始点匹配srci，目标点匹配dsti，或et的目标点匹配srci，起始点匹配dsti；

判定边的匹配后可从结果中过滤掉与查询图任何边都不匹配的边，如上述匹配方法中的最后一行：

filter(et => et.attr.size > 0)

过滤后的结果graphTriplets（3元组）作为后续计算的输入；

S3：从查询计划中取第一个查询子图，计算匹配实例和匹配点集；

假设查询子图的根节点为sqRoot, 所有边为sqEdges，则查询子图的匹配过程如下：

检查graphTriplets中每条边与sqEdges的匹配情况，输出满足条件的边，并以满足sqRoot的那个顶点的id作为key，同时记录对端顶点id以及满足的边，如下：

val edgeMatch = graphTriplets flatMap { et => //res结果内容分别为：root点，对端点， 以及满足的边 val res = new ArrayBuffer[(Long, (Long, BitSet))]()matchEdge(res, et, sqRoot, sqEdges) res.toIterator}

将相同key的数据汇集在一起并检查对端顶点的匹配情况，输出匹配的结果：

val instance = edgeMatch.groupByKey()

flatMap(x => matchInstance(x._1, x._2.toArray, sqEdges))

matchInstance中，查询子图的每个叶子节点需有对应的匹配实例，如果某个叶子节点存在多个匹配实例，则输出组合结果；对于图2的查询子图，假设数据图中id1匹配其根节点，对应的对端顶点中有id2、id3匹配v2， id4、id5匹配v3，id6匹配v4，则matchInstance输出4组匹配实例为：

id1, id2, id4, id6

id1, id2, id5, id6

id1, id3, id4, id6

id1, id3, id5, id6

instance中第一个实例id对应的匹配结果为查询子图的根节点，其他实例id按查询子图的叶子节点的顺序排序，如上述实例匹配的顶点依次是v1, v2, v3, v4

S4：依次从查询计划中取下一个查询子图，计算该查询子图的匹配实例和匹配点集，将其与之前的匹配结果合并；

S5：查询计划执行完成后输出最终的匹配结果；

对应2个查询子图的匹配结果，假设查询子图一的匹配实例为instance1,匹配的顶点为queriedVert1; 查询子图二的匹配实例为instance2,匹配的顶点为queriedVert2；

顶点集的合并方法为：

计算queriedVert1和queriedVert2的交集：

val keyVert = queriedVert1.intersect(queriedVert2)

分别计算queriedVert1和queriedVert2与交集的差集：

val valueVert1 = queriedVert1.diff(keyVert) val valueVert2 =queriedVert2.diff(keyVert)

最终的匹配顶点的集合为3个集合的有序合并：

val resultVert = keyVert ++ valueVert1 ++ valueVert2；

例如对于图2和图4所示的查询子图，其匹配的顶点分别为(v1, v2, v3, v4)和（v3,v5, v6）, 按上述方法计算得到合并结果为：(v3,v1,v2,v4,v5,v6)

匹配方法为：

将instance1每个记录按keyVert和valueVert1 拆分成对应的2部分

val splitInst1 = instance1.map(recorder => splitRecorder(keyVert))

将instance2每个记录按keyVert和valueVert2 拆分成对应的2部分

val splitInst1 = instance2.map(recorder => splitRecorder(keyVert))

将拆分后的2个实例集按keyVert部分的值做关联，将相同keyVert值的valueVert值关联在一起，并检查合并后的匹配情况，对于每个keyVert，对应的valueVert1和valueVert2均需要有值存在，如果存在多组值，则输出组合结果；

val instance = splitInst1.cogroup(splitInst1)

flatMap{ case (key, (valueVert1, valueVert2)) =>

mergeValue(key, valueVert1, valueVert2)}；

例如，假设查询子图的匹配实例为：

id1, id2, id4, id6

id1, id2, id5, id6

id1, id3, id4, id6

id1, id3, id5, id6

拆分的结果为：

id4 -> id1, id2, id6

id5 -> id1, id2, id6

id4 -> id1, id3, id6

id5 -> id1, id3, id6

查询子图2的匹配实例为：

id4, id7, id8

id4, id7, id9

id5, id10, id11

id6, id7, id8

拆分结果为：

id4 -> id7, id8

id4 -> id7, id9

id5 -> id10, id11

id6 -> id7, id8

关联结果为：

id4 -> [(id1, id2, id6), (id1, id3, id6)], [(id7, id8), (id7, id9)]

id5 -> [(id1, id2, id6), (id1, id3, id6)], [(id10, id11)]

id6 -> [], [(id7, id8)]

id4, id5 匹配结果合法，同时输出多组结果，id6匹配失败，因为valueVert1对应部分为空，因此合并结果为：

id4, id1, id2, id6, id7, id8

id4, id1, id2, id6, id7, id9

id4, id1, id3, id6, id7, id8

id4, id1, id3, id6, id7, id9

id5, id1, id2, id6, id10, id11

id5, id1, id3, id6, id10, id11。

综上所述，本发明提供一种Spark并发子图查询的方法，通过当前的子图匹配算法，适用于Spark平台，效率比较高，能使用多台机器并行处理，能力较强，容易处理大规模数据。

本领域技术人员不脱离本发明的实质和精神，可以有多种变形方案实现本发明，以上所述仅为本发明较佳可行的实施例而已，并非因此局限本发明的权利范围，凡运用本发明说明书及附图内容所作的等效结构变化，均包含于本发明的权利范围之内。

Claims (6)

1.一种Spark并发子图查询的方法，其特征在于：包括以下步骤：

S1：生成查询图的查询计划，将其拆分成多个查询子图，每个查询子图包含1条或多条边，所有的边包含一个公共的顶点；

S2：数据图数据预处理，原始数据图给出了每个顶点和边的属性值，查询子图中给出了顶点和边的匹配函数，预处理过程中先判断数据图中每个顶点与查询子图中哪些顶点匹配，数据图中的每条边与查询子图中哪些边匹配；

S3：从查询计划中取第一个查询子图，计算匹配实例和匹配点集；

S4：依次从查询计划中取下一个查询子图，计算该查询子图的匹配实例和匹配点集，将其与之前的匹配结果合并；

S5：查询计划执行完成后输出最终的匹配结果。

2.根据权利要求1所述的一种Spark并发子图查询的方法，其特征在于：根据步骤S1，所述查询图拆分包括以下步骤：

A1：取度数最大的顶点作为查询子图的根节点，所有与根节点相连的边与点构成一个新的查询子图，度数最大的顶点存在多个时可随机选一个；

A2：从查询图删除相应的边，边删除后如果存在孤立的顶点也删除，按步骤A1的方式生成新的查询子图；

A3：如果此查询子图与之前生成的查询子图的顶点有交集，则此查询子图是合法的，否则排除此查询子图的根节点，按步骤A1的方式生成新的查询子图，直到生成满足条件的查询子图；

A4：当所有边都属于某个查询子图时终止。

3.根据权利要求2所述的一种Spark并发子图查询的方法，其特征在于：所述度数为连接的边的数量。

4.根据权利要求1所述的一种Spark并发子图查询的方法，其特征在于：根据步骤S2，

所述顶点匹配判定用一个BitSet来记录数据图中的顶点匹配哪些查询图中的顶点，假设查询图中顶点的数量为numQv，spark并行匹配方法为：

val graphVertexMatch = dataGraph.mapVertices((_, vd) => { val bitSet =new BitSet(numQv) checkVertexMatch(bitSet) bitSet})

图graphVertexMatch中每个顶点的属性记录该顶点与查询图中的哪些顶点匹配；

所述边匹配判定，一条边匹配查询图中的边需同时满足边的属性匹配以及两端顶点属性匹配，得到顶点属性匹配结果后，判定数据图中的每条边与查询图中的哪些边匹配，假设查询图中边的数量为numQe ,spark并行匹配方法为：

val graphTriplets = graphVertexMatch mapEdges(e => { val bitSet = newBitSet(numQe) checkEdgeMatch(bitSet) bitSet}) triplets map(et => matchTriplet(et)) filter(et => et.attr.size > 0)

其中matchTriplet 为边的3元组匹配方法，假设查询图第i条边的起始点为srci，目标点为dsti：

若考虑边的方向，et满足查询图第i条边的条件为：

et的边属性满足i，且j的起始点匹配srci，目标点匹配dsti；

若不考虑边的方向，匹配条件为：

et的边属性满足i，且et的起始点匹配srci，目标点匹配dsti，或et的目标点匹配srci，起始点匹配dsti；

判定边的匹配后可从结果中过滤掉与查询图任何边都不匹配的边，如上述匹配方法中的最后一行：

filter(et => et.attr.size > 0)

过滤后的结果graphTriplets（3元组）作为后续计算的输入。

5.根据权利要求1所述的一种Spark并发子图查询的方法，其特征在于：根据步骤S3假设查询子图的根节点为sqRoot, 所有边为sqEdges，则查询子图的匹配过程如下：

检查graphTriplets中每条边与sqEdges的匹配情况，输出满足条件的边，并以满足sqRoot的那个顶点的id作为key，同时记录对端顶点id以及满足的边，如下：

val edgeMatch = graphTriplets flatMap { et => //res结果内容分别为：root点，对端点， 以及满足的边 val res = new ArrayBuffer[(Long, (Long, BitSet))]()matchEdge(res, et, sqRoot, sqEdges) res.toIterator}

将相同key的数据汇集在一起并检查对端顶点的匹配情况，输出匹配的结果：

val instance = edgeMatch.groupByKey()

flatMap(x => matchInstance(x._1, x._2.toArray, sqEdges))

matchInstance中，查询子图的每个叶子节点需有对应的匹配实例，如果某个叶子节点存在多个匹配实例，则输出组合结果；

instance中第一个实例id对应的匹配结果为查询子图的根节点，其他实例id按查询子图的叶子节点的顺序排序，如上述实例匹配的顶点依次是v1, v2, v3, v4。

6.根据权利要求1所述的一种Spark并发子图查询的方法，其特征在于：根据步骤S4，对应2个查询子图的匹配结果，假设查询子图一的匹配实例为instance1,匹配的顶点为queriedVert1; 查询子图二的匹配实例为instance2,匹配的顶点为queriedVert2；

顶点集的合并方法为：

计算queriedVert1和queriedVert2的交集：

val keyVert = queriedVert1.intersect(queriedVert2)

分别计算queriedVert1和queriedVert2与交集的差集：

val valueVert1 = queriedVert1.diff(keyVert) val valueVert2 =queriedVert2.diff(keyVert)

最终的匹配顶点的集合为3个集合的有序合并：

val resultVert = keyVert ++ valueVert1 ++ valueVert2；

匹配方法为：

将instance1每个记录按keyVert和valueVert1 拆分成对应的2部分

val splitInst1 = instance1.map(recorder => splitRecorder(keyVert))

将instance2每个记录按keyVert和valueVert2 拆分成对应的2部分

val splitInst1 = instance2.map(recorder => splitRecorder(keyVert))

将拆分后的2个实例集按keyVert部分的值做关联，将相同keyVert值的valueVert值关联在一起，并检查合并后的匹配情况，对于每个keyVert，对应的valueVert1和valueVert2均需要有值存在，如果存在多组值，则输出组合结果；

val instance = splitInst1.cogroup(splitInst1)

flatMap{ case (key, (valueVert1, valueVert2)) =>

mergeValue(key, valueVert1, valueVert2)}。