/** * Gets the Filtered attribute of the ConstraintConjunction object * * @return The Filtered value */ public ConstraintConjunction getFiltered() { List<ConstraintExpression> elements = new ArrayList<ConstraintExpression>(this.getElements()); filter(elements); return new ConstraintConjunction(elements); }
protected ConstraintExpression constrainBindings(Map<Variable,Value> bindings) throws TuplesException { List<ConstraintExpression> args = new ArrayList<ConstraintExpression>(); for (Map.Entry<Variable,Value> entry: bindings.entrySet()) { args.add(new ConstraintIs((ConstraintElement) entry.getKey(), (ConstraintElement) entry.getValue())); } return new ConstraintConjunction(args); } }
public ConjAccumulator transformConj(SymbolicTransformationContext context, ConstraintConjunction cc, ConjAccumulator acc) throws SymbolicTransformationException { Iterator args = cc.getElements().iterator(); while (args.hasNext()) { ConstraintExpression arg = (ConstraintExpression)args.next(); if (arg instanceof ConstraintConjunction) { acc = transformConj(context, (ConstraintConjunction)arg, acc); } else if (arg instanceof ConstraintDisjunction) { ConstraintExpression expr = transformDisj(context, (ConstraintDisjunction)arg); acc.accumulate(expr); } else { acc.accumulate(arg); } } return acc; }
public ConstraintExpression bindVariables(Map bindings, ConstraintExpression constraintExpr) throws Exception { return new ConstraintConjunction(ConstraintOperations.replaceOperationArgs(bindings, (ConstraintOperation)constraintExpr)); } }),
private ConstraintExpression constrainBindings(Map bindings) throws LocalizeException { List args = new ArrayList(); Iterator i = bindings.entrySet().iterator(); logger.debug("FIXME:localize should be lookup, need to preallocate MULGARA_IS"); while (i.hasNext()) { Map.Entry entry = (Map.Entry)i.next(); args.add(ConstraintIs.newLocalConstraintIs( (Variable)entry.getKey(), new LocalNode(resolverSession.localize(ConstraintIs.MULGARA_IS)), (ValueElement)entry.getValue(), null)); } return new ConstraintConjunction(args); }
public ConstraintConjunction transformConj(SymbolicTransformationContext context, ConstraintConjunction cc) throws SymbolicTransformationException { ConjAccumulator acc = transformConj(context, cc, new ConjAccumulator(context)); if (!acc.isTransformed()) { return cc; } List args = new ArrayList(); args.addAll(acc.getResidualArgs()); Map varSubByModel = acc.getVarArgsByModel(); Map constSubByModel = acc.getConstArgsByModel(); Set modelSet = new HashSet(); modelSet.addAll(varSubByModel.keySet()); modelSet.addAll(constSubByModel.keySet()); Iterator models = modelSet.iterator(); while (models.hasNext()) { ConstraintElement model = (ConstraintElement)models.next(); args.add(constructConstraintExpression(model, (Map)varSubByModel.get(model), (Map)constSubByModel.get(model))); } return new ConstraintConjunction(args); }
public ConstraintExpression transformExpr(SymbolicTransformationContext context, ConstraintExpression expr) throws SymbolicTransformationException { // This is the main case. if (expr instanceof ConstraintConjunction) { return transformConj(context, (ConstraintConjunction)expr); } // In the case of a Disjunction we need to attempt to transform it's arguments // should the query be in sum of product form. if (expr instanceof ConstraintDisjunction) { return transformDisj(context, (ConstraintDisjunction)expr); } // A single constraint could still be transformed as a singleton conjunction. // Therefore pack in conjunction, attempt transform, and check to see if it was. if (expr instanceof ConstraintImpl) { ConstraintConjunction conj = new ConstraintConjunction(Arrays.asList(new ConstraintExpression[] { expr })); ConstraintConjunction trans = transformConj(context, conj); if (conj == trans) { return expr; } else { return trans; } } // By default we do not recognise the constraint type, so pass it unchanged. return expr; }
/** * Evaluate an aggregate-valued columns's function for the current tuples * row. * * @param subquery the column aggregate function * @throws QueryException if the <var>aggregateFunctions</var>'s embedded * query can't be resolved */ private Object resolveSubquery(Subquery subquery) throws QueryException { if (logger.isDebugEnabled()) logger.debug("Resolving subquery function " + subquery); try { Query query = subquery.getQuery(); Map bindings = createBindingMap(tuples, resolverSession); ConstraintExpression where = new ConstraintConjunction( ConstraintOperations.bindVariables(bindings, query.getConstraintExpression()), constrainBindings(bindings)); query = new Query(query, where); if (logger.isDebugEnabled()) logger.debug("Generated subquery: " + query); return operationContext.doQuery(query); } catch (Exception e) { throw new QueryException("Failed to resolve subquery", e); } }
Tuples resolveMap(Query query, Map outerBindings) throws QueryException { try { Query newQuery = new Query( query.getVariableList(), query.getModelExpression(), new ConstraintConjunction( ConstraintOperations.bindVariables(outerBindings, query.getConstraintExpression()), constrainBindings(outerBindings)), query.getHavingExpression(), query.getOrderList(), query.getLimit(), query.getOffset(), (Answer)query.getGiven().clone()); return operationContext.innerCount(newQuery); } catch (LocalizeException el) { throw new QueryException("Failed to resolve inner local query", el); } }