/** {@inheritDoc} */
@Override
public void insertFederatedQueryOperator(
final ASTService node, final OperatorConnection connection) {
SeveralSucceedingOperators sso = new SeveralSucceedingOperators();
BasicOperator federatedQuery = this.getFederatedQuery(node);
Node child0 = node.jjtGetChild(0);
if (child0 instanceof ASTVar) {
Sort sort = new Sort();
LinkedList<Variable> listOfVars = new LinkedList<Variable>();
listOfVars.add(new Variable(((ASTVar) child0).getName()));
ComparatorVariables comparator = new ComparatorVariables(listOfVars);
sort.setComparator(comparator);
Group group = new Group(comparator);
sort.addSucceedingOperator(group);
group.addSucceedingOperator(federatedQuery);
sso.addSucceedingOperator(sort);
} else {
sso.addSucceedingOperator(federatedQuery);
}
Join join = new Join();
federatedQuery.addSucceedingOperator(join, 1);
sso.addSucceedingOperator(join, 0);
connection.connect(join);
connection.setOperatorConnection(sso);
}
protected void replace(HashMap<Class<?>, HashSet<BasicOperator>> _startNodes) {
// remove obsolete connections...
for (lupos.engine.operators.BasicOperator _parent : this.o1) {
_parent.removeSucceedingOperator(this.f);
this.f.removePrecedingOperator(_parent);
}
for (lupos.engine.operators.BasicOperator _child : this.o2) {
this.f.removeSucceedingOperator(_child);
_child.removePrecedingOperator(this.f);
}
// add new operators...
lupos.rif.operator.RuleFilter rf = null;
rf = new lupos.rif.operator.RuleFilter();
// add new connections...
for (lupos.engine.operators.BasicOperator _parent : this.o1) {
_parent.addSucceedingOperator(rf);
rf.addPrecedingOperator(_parent);
}
for (lupos.engine.operators.BasicOperator _child : this.o2) {
rf.addSucceedingOperator(_child);
_child.addPrecedingOperator(rf);
}
// delete unreachable operators...
this.deleteOperatorWithoutParentsRecursive(this.f, _startNodes);
// additional replace method code...
lupos.optimizations.sparql2core_sparql.SPARQLParserVisitorImplementationDumper filterDumper =
new lupos.optimizations.sparql2core_sparql.SPARQLParserVisitorImplementationDumper();
String equalsString =
(String)
filterDumper.visit(
(lupos.sparql1_1.ASTEqualsNode) this.f.getNodePointer().jjtGetChild(0));
lupos.rif.model.Equality equality = null;
try {
lupos.rif.generated.syntaxtree.RIFAtomic atomic =
new lupos.rif.generated.parser.RIFParser(
new java.io.StringReader(equalsString.substring(1, equalsString.length() - 1)))
.RIFAtomic();
lupos.rif.visitor.ParseSyntaxTreeVisitor rifParser =
new lupos.rif.visitor.ParseSyntaxTreeVisitor();
equality = (lupos.rif.model.Equality) atomic.accept(rifParser, null);
} catch (lupos.rif.generated.parser.ParseException e) {
e.printStackTrace();
return;
}
rf.setExpression(equality);
rf.setUnionVariables(this.f.getUnionVariables());
rf.setIntersectionVariables(this.f.getIntersectionVariables());
}
/** {@inheritDoc} */
@Override
public Tuple<Collection<BasicOperator>, Collection<BasicOperator>> transformOperatorGraph(
final Map<String, BasicOperator> mso, final BasicOperator rootOperator) {
final Collection<BasicOperator> deleted = new LinkedList<BasicOperator>();
final Collection<BasicOperator> added = new LinkedList<BasicOperator>();
final ReplaceVar replaceVar = (ReplaceVar) mso.get("replaceVar");
final LinkedList<BasicOperator> pres =
(LinkedList<BasicOperator>) replaceVar.getPrecedingOperators();
final LinkedList<OperatorIDTuple> succs =
(LinkedList<OperatorIDTuple>) replaceVar.getSucceedingOperators();
BasicOperator pre;
OperatorIDTuple idTuple;
// Connect all precessors to all successors
for (int i = 0; i < pres.size(); i++) {
for (int a = 0; a < succs.size(); a++) {
idTuple = succs.get(a);
pre = pres.get(i);
pre.addSucceedingOperator(new OperatorIDTuple(idTuple.getOperator(), idTuple.getId()));
pre.removeSucceedingOperator(replaceVar);
}
}
BasicOperator succ;
// And all successors to all precessors
for (int i = 0; i < succs.size(); i++) {
for (int a = 0; a < pres.size(); a++) {
succ = succs.get(i).getOperator();
succ.addPrecedingOperator(pres.get(a));
succ.removePrecedingOperator(replaceVar);
}
}
rootOperator.deleteParents();
rootOperator.setParents();
rootOperator.detectCycles();
// should have been done manually: rootOperator.sendMessage(new
// BoundVariablesMessage());
deleted.add(replaceVar);
if (deleted.size() > 0 || added.size() > 0)
return new Tuple<Collection<BasicOperator>, Collection<BasicOperator>>(added, deleted);
else return null;
}
@Override
public Tuple<Collection<BasicOperator>, Collection<BasicOperator>> transformOperatorGraph(
final Map<String, BasicOperator> mso, final BasicOperator rootOperator) {
final GenerateAddEnv genAdd = (GenerateAddEnv) mso.get("genAdd");
final Optional optional = (Optional) mso.get("optional");
final LinkedList<BasicOperator> pres =
(LinkedList<BasicOperator>) genAdd.getPrecedingOperators();
final LinkedList<OperatorIDTuple> succs =
(LinkedList<OperatorIDTuple>) optional.getSucceedingOperators();
BasicOperator pre;
for (int i = 0; i < pres.size(); i++) {
pre = pres.get(i);
pre.addSucceedingOperator(new OperatorIDTuple(optional, 0));
pre.removeSucceedingOperator(genAdd);
optional.addPrecedingOperator(pre);
}
optional.removePrecedingOperator(genAdd);
optional.setSucceedingOperator(new OperatorIDTuple(genAdd, 0));
genAdd.setPrecedingOperator(optional);
genAdd.setSucceedingOperators(succs);
BasicOperator succ;
for (int i = 0; i < succs.size(); i++) {
succ = succs.get(i).getOperator();
succ.addPrecedingOperator(genAdd);
succ.removePrecedingOperator(optional);
}
rootOperator.deleteParents();
rootOperator.setParents();
rootOperator.detectCycles();
rootOperator.sendMessage(new BoundVariablesMessage());
return null;
}