def get_loop_for_join(self, comp, body, query_name):
"""Given a join, create code for iterating over it and running
body. The join is wrapped in a Query node with the given name.
"""
assert self.is_join(comp)
vars = self.lhs_vars_from_comp(comp)
return (L.DecompFor(vars, L.Query(query_name, comp, None), body), )
def generic_visit(self, node):
node = super().generic_visit(node)
# Wrap in Query if it's one of the queries we're given.
name = self.query_name_map.get(node, None)
if name is not None:
self.found.add(node)
node = L.Query(name, node, None)
return node
def rewrite_aggr(self, symbol, name, aggr):
# Only operate on min and max nodes.
if isinstance(aggr.op, L.Min):
func = 'min2'
elif isinstance(aggr.op, L.Max):
func = 'max2'
else:
return
parts = L.get_setunion(aggr.value)
if len(parts) <= 1:
return
multiple_queries = \
len([p for p in parts if not isinstance(p, L.Set)]) > 1
i = 2
done_first_query = False
new_parts = []
for p in parts:
if isinstance(p, L.Set):
# Flatten the literal elements as arguments to
# min2/max2.
new_parts.extend(p.elts)
else:
new_query_node = aggr._replace(value=p)
if done_first_query:
# Create a new query symbol and node for this
# non-literal argument.
new_name = name + '_aggrop' + str(i)
i += 1
new_parts.append(L.Query(new_name, new_query_node,
None))
symtab.define_query(new_name, node=new_query_node,
impl=symbol.impl)
else:
# Push the Query node down to the first non-literal
# argument.
new_parts.append(L.Query(name, new_query_node, None))
symbol.node = new_query_node
done_first_query = True
return L.Call(func, new_parts)
def query_helper(self, node):
first = node is self.firstnode
node = self.generic_visit(node)
# Don't process first node if requested to skip.
if first:
return node
name = next(symtab.fresh_names.queries)
symtab.define_query(name, node=node)
node = L.Query(name, node, None)
return node
def make_node(self):
"""Return a Query node for this query symbol, with no
annotation.
"""
return L.Query(self.name, self.node, None)
