private QueryIterator execFixedSubject(Node nodeURI, Node nodeLocalname, Binding binding, ExecutionContext execCxt)
{
    if ( ! nodeURI.isURI() )
        // Subject bound but not a URI
        return QueryIterNullIterator.create(execCxt) ;

    // Subject is bound and a URI - get the localname as a Node 
    Node localname = NodeFactory.createLiteral(nodeURI.getLocalName()) ;
    
    // Object - unbound variable or a value? 
    if ( ! nodeLocalname.isVariable() )
    {
        // Object bound or a query constant.  Is it the same as the calculated value?
        if ( nodeLocalname.equals(localname) )
            // Same
            return QueryIterSingleton.create(binding, execCxt) ;
        // No - different - no match.
        return QueryIterNullIterator.create(execCxt) ;
    }
    
    // Object unbound variable - assign the localname to it.
    return QueryIterSingleton.create(binding, Var.alloc(nodeLocalname), localname, execCxt) ;
}
 

/**
 * Makes the plan for a SPARQL SOURCE clause.
 *
 * @param elementSource the SPARQL SOURCE
 * @return -
 */
private static BindOrSourcePlan makeSourcePlan(
        final ElementSource elementSource) throws SPARQLExtException {
    Objects.requireNonNull(elementSource, "The Source must not be null");

    Node node = elementSource.getSource();
    Node accept = elementSource.getAccept();
    Var var = elementSource.getVar();

    Objects.requireNonNull(node, "The source must not be null");
    checkIsTrue(node.isURI() || node.isVariable(), "The source must be a"
            + " URI or a variable. Got " + node);
    // accept may be null
    checkIsTrue(accept == null || accept.isVariable() || accept.isURI(),
            "The accept must be null, a variable or a URI. Got " + accept);
    Objects.requireNonNull(var, "The variable must not be null.");

    return new SourcePlan(node, accept, var);
}
 

final public Node VarOrIri() throws ParseException {
                 Node n = null ; String iri ;
  switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  case VAR1:
  case VAR2:
    n = Var();
    break;
  case IRIref:
  case PNAME_NS:
  case PNAME_LN:
    iri = iri();
                            n = createNode(iri) ;
    break;
  default:
    jj_la1[123] = jj_gen;
    jj_consume_token(-1);
    throw new ParseException();
  }
  {if (true) return n ;}
  throw new Error("Missing return statement in function");
}
 

final public Var Var() throws ParseException {
            Token t ;
  switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  case VAR1:
    t = jj_consume_token(VAR1);
    break;
  case VAR2:
    t = jj_consume_token(VAR2);
    break;
  default:
    jj_la1[125] = jj_gen;
    jj_consume_token(-1);
    throw new ParseException();
  }
    {if (true) return createVariable(t.image, t.beginLine, t.beginColumn) ;}
  throw new Error("Missing return statement in function");
}
 

private List<Binding> getNewValues(String queryName, SPARQLExtQuery query, List<Var> signature, List<List<Node>> callParameters) {
    final int size = signature.size();
    final List<Binding> bindings = new ArrayList<>();
    for (List<Node> callParams : callParameters) {
        if (callParams.size() != size) {
            throw new SPARQLExtException("Query " + queryName + " called with " + callParams.size() + " parameters but accepts only " + size);
        }
        final BindingHashMap b = new BindingHashMap();
        for (int i = 0; i < size; i++) {
        	if(callParams.get(i) != null) {
        		b.add(signature.get(i), callParams.get(i));
        	}
        }
        bindings.add(b);
    }
    return bindings;
}
 

public boolean canBeIsomorphic(Node n1, Node n2) {
    if (    (n1.isBlank() || Var.isBlankNodeVar(n1))
         && (n2.isBlank() || Var.isBlankNodeVar(n2)) ) {
        final Node other = map.get(n1);
        if ( other == null ) {
        	if ( valueSet.contains(n2) )
        		return false;

            map.put(n1, n2);
            valueSet.add(n2);
            return true;
        }
        return other.equals(n2);
    }
    return n1.equals(n2);
}
 

private static Map<String, Object> tupleBindings(List<Var> vars, List<Object> t) {
	assert vars.size() == t.size();
	Map<String, Object> result = HashMapFactory.make();
	
	vars = JenaTranslator.sortVars(vars, new Function<Var,String>() {
		@Override
		public String apply(Var arg0) {
			return arg0.getVarName();
		}			
	});

	for(int i = 0; i < vars.size(); i++) {
		result.put(vars.get(i).getVarName(), t.get(i));
	}
	
	if (DEBUG) System.err.println(result);
	return result;
}
 

private static Node replace(Node node, Set<String> assignNeeded, Map<String, Var> assignSuper, Map<String, Var> assign) {
    if (!node.isBlank()) {
        return node;
    }
    String label = node.getBlankNodeLabel();
    if (!assignNeeded.contains(label)) {
        return node;
    }
    if (assignSuper.containsKey(label)) {
        return assignSuper.get(label);
    }
    if (assign.containsKey(label)) {
        return assign.get(label);
    }
    return node;
}
 

/**
 * {@inheritDoc
 */
@Override
public Object visit(Node_List node) {
    if (cache.containsKey(node)) {
        result = cache.get(node);
        return null;
    }
    if (node.getExpr().isVariable()) {
        result = node;
        return null;
    }
    Var var = Var.alloc(node.getLabel());
    final Expr expr = nzer.normalize(node.getExpr());
    bindings.add(new ElementBind(var, expr));
    Node_List nzedList = new Node_List(new ExprVar(var));
    cache.put(node, nzedList);
    this.result = nzedList;
    return null;
}
 

private QueryIterator execAllNodes(Var subjVar, Node nodeLocalname,  Binding input, ExecutionContext execCxt)
{
    if ( ! nodeLocalname.isVariable() )
    {
        if ( ! nodeLocalname.isLiteral() )
            // Not a variable, not a literal=> can't match
            return QueryIterNullIterator.create(execCxt) ;
    
        if( ! NodeUtils.isSimpleString(nodeLocalname) )
            return QueryIterNullIterator.create(execCxt) ;
    }
    
    //Set bindings = new HashSet() ;    // Use a Set if you want unique results. 
    List<Binding> bindings = new ArrayList<Binding>() ;   // Use a list if you want counting results. 
    Graph graph = execCxt.getActiveGraph() ;
    
    ExtendedIterator<Triple>iter = graph.find(Node.ANY, Node.ANY, Node.ANY) ;
    for ( ; iter.hasNext() ; )
    {
        Triple t = iter.next() ;
        slot(bindings, input, t.getSubject(),   subjVar, nodeLocalname) ;
        slot(bindings, input, t.getPredicate(), subjVar, nodeLocalname) ;
        slot(bindings, input, t.getObject(),    subjVar, nodeLocalname) ;
    }
    return new QueryIterPlainWrapper(bindings.iterator(), execCxt) ;
}
 

/**
 * Makes the plan for a SPARQL ITERATOR clause.
 *
 * @param elementIterator the SPARQL ITERATOR
 * @return -
 */
static IteratorPlan makeIteratorPlan(
        final ElementIterator elementIterator)
        throws SPARQLExtException {
    Objects.requireNonNull(elementIterator, "The Iterator must not be null");

    List<Var> vars = elementIterator.getVars();
    Expr expr = elementIterator.getExpr();

    Objects.requireNonNull(vars, "The variables of the Iterator must not be null");
    Objects.requireNonNull(expr, "The Expr in the iterator must not be null");
    checkIsTrue(expr.isFunction(), "Iterator should be a function:"
            + " <iri>(...) AS ?var1 ?var2 ...");

    ExprFunction function = expr.getFunction();
    String iri = function.getFunctionIRI();
    ExprList exprList = new ExprList(function.getArgs());
    return new IteratorPlan(iri, exprList, vars);
}
 

@Override
public List<SortCondition> getOrderBy() {
	List<SortCondition> conditions = new ArrayList<SortCondition>();
	List<OrderCondition> orderConditions = selectQuery
			.getSolutionModifier().getOrderClause();
	for (OrderCondition condition : orderConditions) {
		Var expr = null;
		int dir = ORDER_UNKNOW;
		if (condition.getType() == OrderCondition.EOrderType.ASC) {
			dir = ORDER_ASCENDING;
		} else if (condition.getType() == OrderCondition.EOrderType.DESC) {
			dir = ORDER_DESCENDING;
		}

		SortCondition sortCondition = new SortCondition(expr, dir);
		conditions.add(sortCondition);
	}
	return conditions.size() > 0 ? conditions : null;
}
 

/**
 * Turns a QuerySolution into a Binding. 
 * @param map  the input QuerySolution
 * @return a Binding or null if the input is null
 */
public static Binding asBinding(final QuerySolution map) {
	if(map != null) {
		BindingHashMap result = new BindingHashMap();
		Iterator<String> varNames = map.varNames();
		while(varNames.hasNext()) {
			String varName = varNames.next();
			RDFNode node = map.get(varName);
			if(node != null) {
				result.add(Var.alloc(varName), node.asNode());
			}
		}
		return result;
	}
	else {
		return null;
	}
}
 

public static void runFabricate(String queryFile, SparqlSelectResult result) throws URISyntaxException,
		MalformedURLException, ParserConfigurationException, SAXException,
		IOException {
	Query q = JenaUtil.parse(queryFile);
	List<Var> vars = q.getProjectVars();

	UniverseFactory uf = new BoundedUniverse();

	SolutionRelation r = null;
	if (result != null) {
		uf.addSolution(r = new SolutionRelation(result, vars, Collections.<String,Object>emptyMap()));
	}

	Op query = JenaUtil.compile(q);
	JenaTranslator jt = r==null? JenaTranslator.make(vars, query, uf): JenaTranslator.make(vars, query, uf, r);
	Pair<Formula, Pair<Formula, Formula>> answer = jt.translateSingle(Collections.<String,Object>emptyMap(), false).iterator().next();

	check(uf, answer, "solution");
}
 

public void exec(List<Var> variables, List<Binding> values, Context context) {
	final IndentedWriter writer = ContextUtils.getTemplateOutput(context);
	boolean first = true;
	final FunctionEnv env = new FunctionEnvBase(context);
	String result;
	for(Iterator<Binding> it=values.iterator(); it.hasNext();) {
		Binding binding = it.next();
		if (first && before != null) {
			result = getExprEval(before, binding, context, env);
			writer.print(result);
		}
		if (!first && separator != null) {
			result = getExprEval(separator, binding, context, env);
			writer.print(result);
		}
		result = getExprEval(expr, binding, context, env);
		writer.print(result);
		first = false;
		if (!it.hasNext() && after != null) {
			result = getExprEval(after, binding, context, env);
			writer.print(result);
		}
		writer.flush();
	}
}
 

private Query createQuery(final SPARQLExtQuery select, final List<Var> variables,
		final List<Binding> values, final Context context) {
	// SPARQLExtQuery q = select.cloneQuery();
	Binding binding = !values.isEmpty() ? values.get(0) : null;
	SelectQueryPartialCopyVisitor cloner = new SelectQueryPartialCopyVisitor(binding, context);
	select.visit(cloner);
	Query q = cloner.getOutput();
	if (!isSelectType && !q.hasGroupBy() && !q.hasAggregators()) {
		variables.forEach(v -> {
			if (!q.getProjectVars().contains(v)) {
				q.getProject().add(v);
			}
		});
	}
	return q;
}
 

@Override
public void visitGroupBy(final Query query) {
    if (query.hasGroupBy()) {
    	isDummyQuery = false;
        if (!query.getGroupBy().isEmpty()) {
            VarExprList namedExprs = query.getGroupBy();
            for (Var var : namedExprs.getVars()) {
                Expr expr = namedExprs.getExpr(var);
                if (expr != null) {
                    output.addGroupBy(var, expr);
                    if (!query.isSelectType()) {
                        output.addResultVar(var);
                    }
                } else {
                    output.addGroupBy(var.getVarName());
                    if (!query.isSelectType()) {
                        output.addResultVar(var);
                    }
                }
            }
        }
    }
}
 

private Var toVar(String s) {
	if (s == null)
		return null;
	/* SPARQL 1.1 VAR Gramar ?
	 VARNAME	  ::=  	( PN_CHARS_U | [0-9] ) ( PN_CHARS_U | [0-9] | #x00B7 | [#x0300-#x036F] | [#x203F-#x2040] )*
	 PN_CHARS_U	  ::=  	PN_CHARS_BASE | '_'
	 PN_CHARS_BASE	  ::=  	[A-Z] | [a-z] | [#x00C0-#x00D6] | [#x00D8-#x00F6] | [#x00F8-#x02FF] | [#x0370-#x037D] | [#x037F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
		I've omitted UTF-16 character range #x10000-#xEFFFF.
	*/

	String PN_CHARS_BASE = "A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD";
	String pattern = PN_CHARS_BASE + "0-9\u00B7\u0300-\u036F\u203F-\u2040";

	s = s.trim().replaceAll("[^" + pattern + "]", "_").replace(":", "");

	if ("".equals(s))
		return null;
	return Var.alloc(s);
}
 

private void execIteratorAndSourcePlans(final List<Var> variables, final List<Binding> values,
		final Context context, final int i) {
	if (i < iteratorAndSourcePlans.size()) {
		final BindingsClausePlan plan = iteratorAndSourcePlans.get(i);
		if (plan instanceof BindOrSourcePlan) {
			final BindOrSourcePlan bindOrSourcePlan = (BindOrSourcePlan) plan;
			variables.add(bindOrSourcePlan.getVar());
			final List<Binding> newValues = bindOrSourcePlan.exec(values, context);
			execIteratorAndSourcePlans(variables, newValues, context, i + 1);
			LOG.debug("Finished plan " + bindOrSourcePlan);
		} else {
			IteratorPlan iteratorPlan = (IteratorPlan) plan;
			iteratorPlan.exec(variables, values, context, (newValues) -> {
				final List<Var> newVariables = new ArrayList<>(variables);
				newVariables.addAll(iteratorPlan.getVars());
				execIteratorAndSourcePlans(newVariables, newValues, context, i + 1);
				LOG.debug("Finished batch for " + iteratorPlan);
			});
			LOG.debug("Finished plan " + iteratorPlan);
		}
	} else {
		execSelectPlan(variables, values, context);
	}
}
 

private static ElementData compress(List<Var> variables, List<Binding> input) {
    ElementData el = new ElementData();
    variables.forEach(el::add);
    if (input.size() < 10) {
        input.forEach((b) -> el.add(compress(variables, b)));
        return el;
    }
    for (int i = 0; i < 5; i++) {
        el.add(compress(variables, input.get(i)));
    }
    BindingMap binding = BindingFactory.create();
    Node n = NodeFactory.createLiteral("[ " + (input.size() - 10) + " more ]");
    variables.forEach((v) -> binding.add(v, n));
    el.add(binding);
    for (int i = input.size() - 5; i < input.size(); i++) {
        el.add(compress(variables, input.get(i)));
    }
    return el;
}
 

@Test
public void testROWNUM() throws IOException {
	options = new CSVOptions();
	csv = "First,Last\nAlice,Smith\nBob,Miller";
	String query = "SELECT ?ROWNUM ?First ?Last {} OFFSET 1";
	TarqlQuery tq =  new TarqlParser(new StringReader(query), null).getResult();
	List<Var> vars = vars("ROWNUM", "First", "Last");
	assertSelect(tq, binding(vars, "1", "\"Alice\"", "\"Smith\""), binding(vars, "2", "\"Bob\"", "\"Miller\""));
}
 

@Override
public void visit(OpExtend opExtend) {
	for(Entry<Var, Expr> v : opExtend.getVarExprList().getExprs().entrySet()) {
		add(processVar(v.getKey()));
		processExpr(v.getValue());
	}
}
 

@Override
public void visit(OpProject arg0) {
	visit(arg0.getSubOp(), (TranslatorContext context, Formula f) -> {
		TranslatorContext sub = new DelegatingContext(context) {
			private final Map<String, Variable> vars;
			
			{
				vars = HashMapFactory.make();
				for(Var v : arg0.getVars()) {
					String name = v.getName();
					Variable nv = context.getVars().get(name);
					vars.put(name, nv);
				}
			}
			
			@Override
			public Map<String, Variable> getVars() {
				return vars;
			}
			
		};

		this.context = sub;
		sub.setCurrentQuery(f);
		sub.getCurrentContinuation().next(sub, f);
	});
}
 

private static void addCompressedToElementData(ElementData el, Binding b) {
    final Binding compressed = compress(b);
    final Iterator<Var> varsIterator = compressed.vars();
    while (varsIterator.hasNext()) {
        el.add(varsIterator.next());
    }
    el.add(compressed);
}
 

protected Set<String> getMultipleOccurrenceVars(MultiSet<Var> vars) {
	Set<String> ret = new HashSet<String>();
	for (Var v: vars) {
		if (vars.getCount(v)>1) {
			ret.add(v.getName());
		}
	}
	return ret;
}
 

@Test
public void testSelectWithFilter() throws IOException {
	csv = "Alice,Smith\nBob,Cook";
	String query = "SELECT * { FILTER(?b=\"Smith\") }";
	TarqlQuery tq =  new TarqlParser(new StringReader(query), null).getResult();
	List<Var> vars = vars("a", "b");
	assertSelect(tq, binding(vars, "\"Alice\"", "\"Smith\""));
}
 

@Override
public void visit(ExprVar nv) {
	String s = nv.getVarName();
	if (Var.isBlankNodeVarName(s)) {
		// Return to a bNode via the bNode mapping of a variable.
		Var v = Var.alloc(s);
		out.print(context.getBNodeMap().asString(v));
	} else {
		// Print in variable form or as an aggregator expression
		out.print(nv.asSparqlExpr());
	}
}
 

@Test
public void testBindData() throws IOException {
	csv = "x";
	String query = "SELECT * { BIND (?a AS ?b) }";
	TarqlQuery tq =  new TarqlParser(new StringReader(query), null).getResult();
	List<Var> vars = vars("a", "b");
	assertSelect(tq, binding(vars, "\"x\"", "\"x\""));
}
 

void printSignature(SPARQLExtQuery query) {
    out.print("(");
    boolean first = true;
    List<Var> signature = query.getSignature();
    for (int i = 0; i < signature.size(); i++) {
        Var var = signature.get(i);
        if (i != 0) {
            out.print(", ");
        }
        out.print("?");
        out.print(var.getName());
        first = false;
    }
    out.print(")");
}
 

public static Binding binding(List<Var> header, String... values) {
	if (header.size() != values.length) {
		throw new IllegalArgumentException(
				"header and values must have same length: " + 
						header + ", " + Arrays.toString(values));
	}
	BindingHashMap result = new BindingHashMap();
	for (int i = 0; i < header.size(); i++) {
		result.add(header.get(i), NodeFactoryExtra.parseNode(values[i]));
	}
	return result;
}