public Object eval(Expr exp, Object[] param){ return evaluator.eval(exp, memory, producer, param); }
/** * Generate a unique Blank Node wrt query that represents the path Use a * predefined filter pathNode() */ Node getPathNode(Path p) { Filter f = query.getGlobalFilter(Query.PATHNODE); Node node = evaluator.eval(f, memory, producer); node.setObject(p); return node; }
/** * Mapping as Environment may compute aggregates see same function in Memory */ @Override public void aggregate(Evaluator eval, Producer p, Filter f) { if (!getMappings().isFake()) { for (Mapping map : getMappings()) { // in case there is a nested aggregate eval.eval(f, map, p); } } }
void orderGroup(List<Exp> lExp, Node[] nodes, Producer p) { int n = 0; for (Exp e : lExp) { Node qNode = e.getNode(); if (qNode != null) { nodes[n] = getNode(qNode); } if (nodes[n] == null) { Filter f = e.getFilter(); if (f != null && !e.isAggregate()) { nodes[n] = eval.eval(f, this, p); } } n++; } }
Node tnode = eval.getEvaluator().eval(f, m, p); if (tnode != null) { Node val = m.getNodeValue(qnode);
void orderGroup(List<Exp> lExp, Node[] nodes, Producer p, Mapping m) { int n = 0; for (Exp e : lExp) { Node qNode = e.getNode(); if (qNode != null) { nodes[n] = m.getNodeValue(qNode); } if (nodes[n] == null) { Filter f = e.getFilter(); if (f != null && !e.isAggregate()) { nodes[n] = eval.getEvaluator().eval(f, m, p); } } n++; } }
/** * Subquery processed by a function call that return Mappings Producer may * cast the result into Mappings use case: {select xpath(?x, '/book/title') * as ?val where {}} Mappings may be completed by filter (e.g. for casting) * Mappings will be processed later by aggregates and order by/limit etc. */ private void function() { Exp exp = query.getFunction(); if (exp == null) { return; } Mappings lMap = evaluator.eval(exp.getFilter(), memory, exp.getNodeList()); if (lMap != null) { for (Mapping map : lMap) { map = complete(map, producer); submit(map); } } }
/** * additional filter of functional select xpath() as ?val xsd:integer(?val) * as ?int */ private Mapping complete(Mapping map, Producer p) { for (Exp ee : query.getSelectFun()) { Filter f = ee.getFilter(); if (f != null && !f.isFunctional()) { memory.push(map, -1); Node node = evaluator.eval(f, memory, producer); memory.pop(map); map.setNode(ee.getNode(), node); } } if (query.getOrderBy().size() > 0 || query.getGroupBy().size() > 0) { memory.push(map, -1); Mapping m = memory.store(query, p, true, true); memory.pop(map); map = m; } return map; }
/** * Generic aggregate eval is Walker it applies the aggregate f (e.g. * sum(?x)) on the list of Mapping with Mapping as environment to get * variable binding */ void aggregate(Evaluator eval, Filter f, Environment env, Producer p) { if (isFake()) { // fake Mappings because there were no result return; } int n = 0; for (Mapping map : this) { this.setCount(n++); // in case there is a nested aggregate, map will be an Environment // it must implement aggregate() and hence must know current Mappings group map.setMappings(this); map.setQuery(env.getQuery()); // share same bnode table in all Mapping of current group solution map.setMap(env.getMap()); eval.eval(f, map, p); } }
private int extBind(Producer p, Node gNode, Exp exp, Stack stack, int n) { int backtrack = n - 1; Memory env = memory; Mappings map = evaluator.eval(exp.getFilter(), env, exp.getNodeList()); getVisitor().values(this, getGraphNode(gNode), exp, map); if (map != null) { HashMap<String, Node> tab = toMap(exp.getNodeList()); for (Mapping m : map) { if (stop) { return STOP; } if (env.push(tab, m, n)) { backtrack = eval(p, gNode, stack, n + 1); env.pop(tab, m); if (backtrack < n) { return backtrack; } } } } return backtrack; }
/** * Template perform additionnal group_concat(?out) */ public Node apply(Evaluator eval, Exp exp, Memory memory, Producer p) { Mapping firstMap = get(0); // bind the Mapping in memory to retrieve group by variables memory.aggregate(firstMap); if (size() == 1) { // memory.getNode(?out) Node node = memory.getNode(exp.getFilter().getExp().getExp(0)); //if (node == null || ! node.isFuture()){ if (node != null && !node.isFuture()) { // if (node == null) go to aggregate below because we want it to be uniform // whether there is one or several results return node; } } Node node = eval.eval(exp.getFilter(), memory, p); memory.pop(firstMap); return node; }
/** * bind(exp as var) */ private int bind(Producer p, Node gNode, Exp exp, Stack stack, int n) { if (exp.isFunctional()) { return extBind(p, gNode, exp, stack, n); } int backtrack = n - 1; Memory env = memory; env.setGraphNode(gNode); Node node = evaluator.eval(exp.getFilter(), env, p); env.setGraphNode(null); getVisitor().bind(this, getGraphNode(gNode), exp, node==null?null:node.getDatatypeValue()); if (node == null) { backtrack = eval(p, gNode, stack, n + 1); } else if (memory.push(exp.getNode(), node, n)) { backtrack = eval(p, gNode, stack, n + 1); memory.pop(exp.getNode()); } return backtrack; }
node = eval.eval(exp.getFilter(), memory, p); if (ev != null) { ev.getVisitor()
node = eval.eval(f, this, p); kgram.getVisitor().select(kgram, f.getExp(), node==null?null:node.getDatatypeValue());