def create_plan_tree(self, decomp):
unionblocks = []
sblocks = []
opblocks = []
for ub in decomp:
BGP = ub['BGP']
joinplans, non_match_filters = decompose_block(BGP, ub['Filter'], self.config, isTreeBlock=True)
if len(ub['JoinBlock']) > 0:
joinBlock = self.create_plan_tree(ub['JoinBlock'])
sblocks.append(JoinBlock(joinBlock))
if len(ub['UnionBlock']) > 0:
unionBlock = self.create_plan_tree(ub['UnionBlock'])
sblocks.append(UnionBlock(unionBlock))
if len(ub['Optional']) > 0:
opblocks.append(Optional(UnionBlock(self.create_plan_tree(ub['Optional']))))
bgp_triples = []
[bgp_triples.extend(BGP['stars'][s]['triples']) for s in BGP['stars']]
[joinplans.append(s) for s in sblocks]
gp = makeBushyTree(joinplans, get_filters(bgp_triples, non_match_filters))
gp = [gp] + opblocks
gp = JoinBlock(gp)
unionblocks.append(gp)
return unionblocks
def create_decomposed_query(self, decomp):
unionblocks = []
sblocks = []
opblocks = []
for ub in decomp:
BGP = ub['BGP']
joinplans = decompose_block(BGP,
ub['Filter'],
self.config,
isTreeBlock=False)
if len(ub['JoinBlock']) > 0:
joinBlock = self.create_decomposed_query(ub['JoinBlock'])
sblocks.append(JoinBlock(joinBlock))
if len(ub['UnionBlock']) > 0:
unionBlock = self.create_decomposed_query(ub['UnionBlock'])
sblocks.append(UnionBlock(unionBlock))
if len(ub['Optional']) > 0:
opblocks.append(
Optional(
UnionBlock(self.create_decomposed_query(
ub['Optional']))))
gp = joinplans + sblocks + opblocks
gp = UnionBlock([JoinBlock(gp)])
unionblocks.append(gp)
return unionblocks
def p_join_block_0(p):
"""
join_block : LKEY union_block RKEY rest_join_block
"""
if (p[4] != [] and isinstance(p[4][0], Filter)):
p[0] = [UnionBlock(p[2])] + p[4]
elif p[4] != []:
p[0] = [UnionBlock(p[2])] + [JoinBlock(p[4])]
else:
p[0] = [UnionBlock(p[2])]
def p_union_block_0(p):
"""
union_block : pjoin_block rest_union_block POINT pjoin_block
"""
punion = [JoinBlock(p[1])] + p[2]
pjoin = [UnionBlock(punion)] + p[4]
p[0] = [JoinBlock(pjoin)]
def make_plan(self):
trree = self._make_tree()
# print("------------->>", trree)
# print(self.decompositions)
self.query.body = UnionBlock(trree)
operatorTree = self.includePhysicalOperatorsQuery()
# print(operatorTree)
if operatorTree is None:
return []
# Adds the project operator to the plan.
operatorTree = NodeOperator(Xproject(self.query.args), operatorTree.vars, self.config, operatorTree)
# Adds the distinct operator to the plan.
if (self.query.distinct):
operatorTree = NodeOperator(Xdistinct(None), operatorTree.vars, self.config, operatorTree)
# Adds the offset operator to the plan.
if (self.query.offset != -1):
operatorTree = NodeOperator(Xoffset(None, self.query.offset), operatorTree.vars, self.config, operatorTree)
# Adds the limit operator to the plan.
if (self.query.limit != -1):
# print "query.limit", query.limit
operatorTree = NodeOperator(Xlimit(None, self.query.limit), operatorTree.vars, self.config, operatorTree)
return operatorTree
def p_union_block_1(p):
"""
union_block : pjoin_block rest_union_block pjoin_block
"""
punion = [JoinBlock(p[1])] + p[2]
if p[3] != []:
pjoin = [UnionBlock(punion)] + p[3]
p[0] = [JoinBlock(pjoin)]
else:
p[0] = [JoinBlock(p[1])] + p[2]
def p_bgp_01(p):
"""
bgp : bgp UNION bgp rest_union_block
"""
ggp = [JoinBlock([p[1]])] + [JoinBlock([p[3]])] + p[4]
p[0] = UnionBlock(ggp)
def p_bgp_0(p):
"""
bgp : LKEY bgp UNION bgp rest_union_block RKEY
"""
ggp = [JoinBlock([p[2]])] + [JoinBlock([p[4]])] + p[5]
p[0] = UnionBlock(ggp)
def p_ggp_0(p):
"""
group_graph_pattern : union_block
"""
p[0] = UnionBlock(p[1])
def updateFilters(self, node, filters):
return UnionBlock(node.triples, filters)
def decompose_block(BGP, filters, config, isTreeBlock=False):
joinplans = []
services = []
filter_pushed = False
non_match_filters = []
ssqs = list(BGP['stars'].keys())
ssqs = sorted(ssqs)
for s in ssqs:
star = BGP['stars'][s]
dss = star['datasources']
preds = star['predicates']
sources = set()
star_filters = get_filters(list(set(star['triples'])), filters)
for ID, rdfmt in dss.items():
for mt, mtpred in rdfmt.items():
ppred = [p for p in preds if '?' not in p]
if len(
set(preds).intersection(mtpred + [
'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'
])) == len(set(preds)) or len(ppred) == 0:
sources.add(ID)
break
if len(sources) > 1:
sources = sorted(sources)
if isTreeBlock:
elems = [
JoinBlock([
makeBushyTree([
Service(
endpoint="<" + config.datasources[d].url + ">",
triples=star['triples'],
datasource=config.datasources[d],
rdfmts=list(star['datasources'][d].keys()),
star=star)
], star_filters)
],
filters=star_filters) for d in sources
]
else:
elems = [
JoinBlock([
Service(endpoint="<" + config.datasources[d].url + ">",
triples=star['triples'],
datasource=config.datasources[d],
rdfmts=star['rdfmts'],
star=star,
filters=get_filters(list(set(star['triples'])),
filters))
]) for d in sources
]
ubl = UnionBlock(elems)
joinplans = joinplans + [ubl]
elif len(sources) == 1:
d = sources.pop()
serv = Service(endpoint="<" + config.datasources[d].url + ">",
triples=star['triples'],
datasource=config.datasources[d],
rdfmts=star['rdfmts'],
star=star,
filters=star_filters)
services.append(serv)
if len(filters) == len(star_filters):
filter_pushed = True
else:
non_match_filters = list(set(filters).difference(star_filters))
services = push_down_join(services)
if services and joinplans:
joinplans = services + joinplans
elif services:
joinplans = services
# joinplans = makeBushyTree(joinplans, filters)
return joinplans, non_match_filters if not filter_pushed else []