private void addFilterConditions(
final JoinConditions conditions,
final HashMap<String, Set<MappableNodeFilter>> filters,
final Set<MappableNodePattern> joinableVars,
final HashMap<String, String> variableBindings) {
for (String filterVar : new ArrayList<String>(filters.keySet())) {
for (MappableNodePattern joinableVar : joinableVars) {
if (joinableVar.isVariable() && joinableVar.getVarName().equals(filterVar)) {
for (MappableNodeFilter f : filters.get(filterVar)) {
String right;
String left;
if (f.getNode().isVariable() && f.getNode().getVarName().equals(filterVar)) {
left = getBoundValue(joinableVar, variableBindings);
} else if (f.getNode().isVariable()) {
left = getBoundValue(f.getNode(), variableBindings);
} else {
left = DBUtil.quotedString(f.getNode().getNode().toString(), backslashEscape);
}
if (f.getConstraint().isVariable()
&& f.getConstraint().getVarName().equals(filterVar)) {
right = getBoundValue(joinableVar, variableBindings);
} else if (f.getConstraint().isVariable()) {
right = getBoundValue(f.getConstraint(), variableBindings);
} else {
right = DBUtil.quotedString(f.getConstraint().getNode().toString(), backslashEscape);
}
conditions.addCondition(left, f.getOperator(), right);
LOG.debug(
"parseGraphPattern: Adding filter "
+ "condition: "
+ left
+ " "
+ f.getOperator()
+ " "
+ right
+ "\n");
}
removeFromMap(filters.get(filterVar), filters);
}
}
}
}
private void processFilter(
final MappableTriplePattern p, final String varName, final MappableNodeFilter f)
throws QueryException {
String mappedName;
if (p.getSubject().isVariable() && p.getSubject().getVarName().equals(varName)) {
mappedName = p.getSubject().mappedName();
} else if (p.getObject().isVariable() && p.getObject().getVarName().equals(varName)) {
mappedName = p.getObject().mappedName();
} else {
throw new QueryException("Variable " + varName + " in filter Cannot be found in graph query");
}
if (!valueBindings.containsKey(mappedName)) {
valueBindings.put(mappedName, new HashSet<String>());
}
if (f.getNode().isVariable() && f.getNode().getVarName().equals(varName)) {
if (f.getConstraint().isVariable()) {
/* XXX It's probably not legal to be here.. */
LOG.warn("Node filter constraint is variable? " + "It's probably not legal to be here...");
} else {
valueBindings
.get(mappedName)
.add(
mappedName
+ " "
+ f.getOperator()
+ " "
+ DBUtil.quotedString(f.getConstraint().getNode().toString(), backslashEscape));
LOG.debug(
"Remaining Filters: "
+ mappedName
+ " "
+ f.getOperator()
+ " '"
+ f.getConstraint().getNode()
+ "'"
+ "\n");
}
} else if (f.getConstraint().isVariable() && f.getConstraint().getVarName().equals(varName)) {
if (f.getNode().isVariable()) {
/* XXX: it's probably not legal to be here.. */
LOG.warn(
"Node filter constraint is variable and node is "
+ "variable? It's probably not legal to be here...");
} else {
valueBindings
.get(mappedName)
.add(
DBUtil.quotedString(f.getNode().getNode().toString(), backslashEscape)
+ " "
+ f.getOperator()
+ " "
+ mappedName);
LOG.debug(
"Remaining Filters: "
+ "'"
+ f.getNode().getNode()
+ "' "
+ f.getOperator()
+ " "
+ mappedName
+ "\n");
}
}
}
private Joinable parseGraphPattern(
final GraphPattern g, final HashMap<String, String> variableBindings) throws QueryException {
LOG.debug("parsing graph pattern " + g);
/* First, organize the filters by variable so that we can map them */
HashMap<String, Set<MappableNodeFilter>> filters =
new HashMap<String, Set<MappableNodeFilter>>();
/* We're given NodeFilters, but need MappableNodeFilters. Convert. */
Set<MappableNodeFilter<Node>> givenFilters = new HashSet<MappableNodeFilter<Node>>();
for (NodeFilter<Node> filter : g.getFilters()) {
givenFilters.add(new MappableNodeFilter<Node>(filter));
}
/*
* For each given filter, if the value or constraint is a variable,
* place it in the filter pool.
*/
for (MappableNodeFilter f : givenFilters) {
if (f.getNode().isVariable()) {
if (!filters.containsKey(f.getNode().getVarName())) {
LOG.debug("Adding " + f.getNode().getVarName() + " To filter pool..\n");
filters.put(f.getNode().getVarName(), new HashSet<MappableNodeFilter>());
}
filters.get(f.getNode().getVarName()).add(f);
}
if (f.getConstraint().isVariable()) {
if (!filters.containsKey(f.getConstraint().getVarName())) {
LOG.debug("Adding " + f.getConstraint().getVarName() + " To filter pool..\n");
filters.put(f.getConstraint().getVarName(), new HashSet<MappableNodeFilter>());
}
filters.get(f.getConstraint().getVarName()).add(f);
}
if (!(f.getNode().isVariable() || f.getConstraint().isVariable())) {
throw new IllegalArgumentException(
"Triple filters must "
+ "contain a variable. Neither "
+ f.getNode().getVarName()
+ " nor "
+ f.getConstraint().getVarName()
+ " is a variable!");
}
}
/* Next, process each triple pattern in this graph pattern */
LinkedList<MappableTriplePattern> steps = new LinkedList<MappableTriplePattern>();
for (TriplePattern p : g.getTriplePatterns()) {
steps.add(new MappableTriplePattern(p));
}
/*
* We create an initial join sequence from the first triple pattern NB:
* We require that all triple patterns in a graph pattern can be joined,
* so it is OK to do this
*/
MappableTriplePattern step = null;
boolean successfullyBoundFirstStep = false;
while (!steps.isEmpty()) {
step = steps.removeFirst();
if (!bindPattern(step, variableBindings)) {
continue;
} else {
successfullyBoundFirstStep = true;
break;
}
}
if (!successfullyBoundFirstStep) {
LOG.info("Pattern is entirely redundant. Ignoring: " + g);
return null;
}
JoinSequence joins = new JoinSequence(new JoinTable(step));
/* We keep track of all tje variables that are available to join on */
Set<MappableNodePattern> joinableVars = joins.joinVars();
/* For all the remaining steps.. */
while (!steps.isEmpty()) {
step = getJoinablePattern(steps, variableBindings);
if (step == null) {
throw new QueryException(
"Cannot bind all query steps! \n"
+ "remaining:\n"
+ steps
+ "\nvariables already bound:\n "
+ variableBindings.keySet()
+ "\n");
}
steps.remove(step);
bindPattern(step, variableBindings);
JoinTable table = new JoinTable(step);
joinableVars.addAll(table.joinVars());
JoinConditions conditions = new JoinConditions();
/* Create all possible joins */
addJoinConditions(conditions, step, variableBindings);
/* Add any filter constraints */
addFilterConditions(conditions, filters, joinableVars, variableBindings);
/* Fold in any remaining constant bindings */
for (MappableNodePattern var : joinableVars) {
if (valueBindings.containsKey(var.boundTable().alias())) {
for (String condition : valueBindings.get(var.boundTable().alias())) {
LOG.debug(
"parseGraphPattern: Adding remaining " + "constant conditions " + condition + "\n");
conditions.addCondition(condition);
}
valueBindings.remove(var.boundTable().alias());
}
}
/* Finally, add the join to the sequence */
joins.addJoin(JoinType.INNER_JOIN, table, conditions);
}
/*
* If we still have filters yet unapplied, that is legitimate only if
* this pattern has a length of 1 AND it contains a variable that
* matches the filter...
*/
if (filters.values().size() > 0 && g.getTriplePatterns().size() > 1) {
throw new QueryException("Filter is unbound");
}
/* .. If so, then get that one pattern */
MappableTriplePattern p = new MappableTriplePattern(g.getTriplePatterns().get(0));
/* ... and Process any remaining filters */
for (String varName : filters.keySet()) {
for (MappableNodeFilter f : filters.get(varName)) {
processFilter(p, varName, f);
}
}
return joins;
}