def create_plan(self, query):
self.query = query
logical_plan = self.get_logical_plan(query.body)
physical_plan = PhysicalPlan(self.sources, self.eddies, logical_plan, query, poly_operator=self.poly,
**(self.operators))
physical_plan.planning_requests = self.planning_requests
return physical_plan
def create_plan(self, query):
self.query = query
logical_plan = self.get_logical_plan(query.body)
physical_plan = PhysicalPlan(self.sources,
self.eddies,
logical_plan,
query,
poly_operator=self.poly,
sparql_limit=self.sparql_limit,
sparql_mappings=self.sparql_mapping_cnt,
brtpf_mappings=self.brtpf_mapping_cnt)
physical_plan.planning_requests = self.planning_requests
return physical_plan
def custom_plan(sources):
tp_1 = TriplePattern(Argument("?v3"),
Argument("<http://schema.org/trailer>"),
Argument("?v5"))
tp_2 = TriplePattern(
Argument("?v3"),
Argument("http://www.w3.org/1999/02/22-rdf-syntax-ns#type>"),
Argument("<http://db.uwaterloo.ca/~galuc/wsdbm/ProductCategory2>"))
tp_3 = TriplePattern(
Argument("?v3"),
Argument("<http://db.uwaterloo.ca/~galuc/wsdbm/hasGenre>"),
Argument("?v0"))
tps = [tp_1, tp_2, tp_3]
# XNJoin = Nested Loop Join
# FJoin: Hash Join
l_plan = LogicalPlan(LogicalPlan(LogicalPlan(tp_1),
LogicalPlan(tp_2),
operator=Xnjoin),
LogicalPlan(tp_3),
operator=Xnjoin)
plan = PhysicalPlan(sources, 2, l_plan, poly_operator=False)
return plan
def create_plan(self, query):
self.query = query
logical_plan = self.get_logical_plan(query.body)
return
physical_plan = PhysicalPlan(self.sources,
self.eddies,
logical_plan,
query,
poly_operator=self.poly)
return physical_plan
def create_best(self, triple_patterns, query):
start = time()
best_plan = None
max_delta = 0
prev_delta = 0
evals = 0
best_rob = float("inf")
done = False
while not done:
for i in range(100):
max_delta = 0
try:
plan = self.random_plan(triple_patterns)
plan.compute_cost(self.cost_model)
pp = PhysicalPlan(self.source, self.eddies,
plan.logical_plan, query)
rob = pp.average_cost(self.cost_model)
evals += 1
if not best_plan:
best_plan = plan
delta = plan.cost - best_plan.cost
if delta > max_delta:
max_delta = delta
if delta < 0:
best_plan = plan
except Exception as e:
pass
print(max_delta, prev_delta)
if max_delta - prev_delta < 0:
break
else:
prev_delta = max_delta
done = True
print evals
print best_plan.cost, rob
print(time() - start)
return pp
if key == 'right':
right = dict_to_logical(plan_dict['right'])
if key == 'left':
left = dict_to_logical(plan_dict['left'])
if key == 'type':
if value == 'NLJ':
join = Xnjoin
else:
join = Fjoin
if key == 'tpf':
arguments = value.split(" ")[:-1]
# triple_pattern = " ".join(triples)
triple_pattern = TriplePattern(Argument(arguments[0]),
Argument(arguments[1]),
Argument(arguments[2]))
return LogicalPlan(triple_pattern)
return LogicalPlan(left, right, join)
sources = ["tpf@http://aifb-ls3-vm8.aifb.kit.edu:5000/watdiv"]
lplan = dict_to_logical(plan_dict)
plan1 = PhysicalPlan(sources, 2, lplan, poly_operator=False)
from custom_plan import custom_plan
plan2 = custom_plan(sources)
print 'Are they equal: ' + str(plan1 == plan2)
graph.setdefault(i, [])
graph.setdefault(j, [])
colors = color_nodes(graph)
subqueries = {}
for id, tp in id2tp.items():
if not colors[id] in subqueries.keys():
subqueries[colors[id]] = ([], set())
subqueries[colors[id]][0].append(tp)
subqueries[colors[id]][1].update(tp.sources.keys())
D = capability_aware_decomp(subqueries)
lplan = decomposition_to_plan(D)
print lplan
plan = PhysicalPlan(sources, 2, lplan, poly_operator=True)
En = EddyNetwork()
result_count = 0
for result in En.execute_standalone(plan):
#print result
result_count += 1
request = 0
with open('../../logs/{}.log'.format(queryname), "r") as infile:
try:
for line in infile.readlines():
if "request" in line:
dct = literal_eval(line)
request += dct['requests']
except Exception as e: