public boolean commonVarConstant() { return commonVar.isConstant(); }
private int numberOfSpVars(StatementPattern sp) { List<Var> varList = sp.getVarList(); int varCount = 0; for(int i = 0; i < 3; i++) { if(!varList.get(i).isConstant()) { varCount++; } } return varCount; }
private static String getVarName(ValueExpr v) { if(v instanceof Var) { Var var = (Var) v; if(!var.isConstant()) { return var.getName(); } } return null; } }
private static String getVarName(ValueExpr v) { if(v instanceof Var) { Var var = (Var) v; if(!var.isConstant()) { return var.getName(); } } return null; } }
private static boolean genConstantCompare(StatementPattern queryNode, StatementPattern indexNode) { ArrayList<Var> vars1 = (ArrayList<Var>) queryNode.getVarList(); ArrayList<Var> vars2 = (ArrayList<Var>) indexNode.getVarList(); for (int i = 0; i < vars1.size(); i++) { if (vars1.get(i).isConstant() && vars2.get(i).isConstant()) { if (!vars1.get(i).equals(vars2.get(i))) { return false; } } else if(!vars1.get(i).isConstant() && vars2.get(i).isConstant() ) { return false; } } return true; }
/** * Returns true if this rule is applicable to a node. * * @param node to a node * @return true if the rule is applicable, false otherwise */ @Override public boolean canApply(StatementPattern node) { Var p = node.getPredicateVar(); // check if predicate is variable return !(predicates.isEmpty() || p.isConstant()); }
@Override public void meet(Var node) throws RuntimeException { if (node.isConstant()) { String key = node.getValue().toString(); if(constantMap.containsKey(key)){ int count = constantMap.get(key); count += 1; constantMap.put(key, count); } else { constantMap.put(key, 1); } } }
/** * Verifies all of the Statement Patterns have Constants for their predicates. * * @param patterns - The patterns to check. (not null) * @throws IllegalStateException A pattern has a variable predicate. */ private static void verifyAllPredicatesAreConstants(final Collection<StatementPattern> patterns) throws IllegalStateException { requireNonNull(patterns); for(final StatementPattern pattern : patterns) { if(!pattern.getPredicateVar().isConstant()) { throw new IllegalStateException("The Predicate of a Statement Pattern must be constant. Pattern: " + pattern); } } }
private static List<List<String>> genGetCommonVars(List<Var> vars1, List<Var> vars2) { List<List<String>> varList = Lists.newArrayList(); List<String> varList1 = Lists.newArrayList(); List<String> varList2 = Lists.newArrayList(); for (int i = 0; i < vars1.size(); i++) { if (!vars1.get(i).isConstant() && !vars2.get(i).isConstant()) { varList1.add(vars1.get(i).getName()); varList2.add(vars2.get(i).getName()); } else if(vars1.get(i).isConstant() && !vars2.get(i).isConstant()) { varList1.add(vars1.get(i).getName()); varList2.add(vars2.get(i).getName()); } } varList.add(varList1); varList.add(varList2); return varList; }
public Set<String> getBindingNames() { //resource and match variable for search are already included as standard result-bindings Set<String> bindings = Sets.newHashSet(); for(Var v: spConstraint.getVarList()) { if(!v.isConstant()) { bindings.add(v.getName()); } } return bindings; }
@Override public void meet(Var node) throws RuntimeException { if(!node.isAnonymous() && !node.isConstant()) { variables.add(node.getName()); } } }
public void meet(Var var) { if (var.isConstant()) { valMap.put(var.getName(),var.getValue()); } }
/** * Returns the URI of a constant {@link Var} object. * * @param v the {@link Var} object * @return URI as string if it is a URI, null otherwise */ protected String getURIString(Var v) { if (v.isConstant()) { Value val = v.getValue(); if (val instanceof URI) { URI uri = (URI) val; return uri.stringValue(); } } return null; }
public void meet(Var var) { if (!var.isConstant() && hMap.containsKey(var.getName())) { String val = hMap.get(var.getName()); if (val.startsWith("-const-")) { var.setName(val); var.setValue(valMap.get(val)); var.setAnonymous(true); //TODO this might be a hack -- when are Vars not anonymous? } else { var.setName(val); } } }
@Override public void meet(Var var) { if (!(var.getParentNode() instanceof NAryValueOperator)) { if (!var.isConstant() && hMap.containsKey(var.getName())) { String val = hMap.get(var.getName()); if (val.startsWith("-const-")) { var.replaceWith(new ValueConstant(valMap.get(val))); } else { var.setName(val); } } } }
@Override public void meet(Var node) throws Exception { int count = 1; if (!node.isConstant()) { if (varMap.containsKey(node.getName())) { count = varMap.get(node.getName()); count++; varMap.put(node.getName(), count); } else varMap.put(node.getName(), 1); if (!emptyVarMap.containsKey(node.getName())) emptyVarMap.put(node.getName(), 0); } super.meet(node); }
private void init() throws RyaTypeResolverException { commonVar = this.getCommonVar(nodes); if(!commonVar.isConstant()) { commonVarName = commonVar.getName(); } else { commonVarName = commonVar.getName().substring(7); } if(hasContext()) { final RyaURI ctxtURI = (RyaURI) RdfToRyaConversions.convertValue(context.getValue()); contextURI = ctxtURI.getData(); } for(int i = 0; i < nodes.size(); i++){ nodeColumnCond[i] = nodeToTextColumn(nodes.get(i), i); } }
@Override public void meet(Var node) throws RDFHandlerException { Value value; if (node.isConstant()) { value = node.getValue(); } else { value = getVar(node.getName()); } handler.handleStatement(valueFactory.createStatement(subject, predicate, value)); }
@Override public void meet(Var var) { Var replacement = s.get(var); if (replacement == null) return; var.setName(replacement.getName()); var.setConstant(replacement.isConstant()); var.setValue(replacement.getValue()); }
private HashMultimap<String, StatementPattern> getVarBins(List<TupleExpr> nodes) { HashMultimap<String, StatementPattern> varMap = HashMultimap.create(); for (QueryModelNode node : nodes) { if (node instanceof StatementPattern) { StatementPattern sp = (StatementPattern) node; if (sp.getPredicateVar().isConstant()) { varMap.put(sp.getSubjectVar().getName(), sp); varMap.put(sp.getObjectVar().getName(), sp); } } } removeInvalidBins(varMap, true); return varMap; }