/** * ******************************************************** * * @param el */ public void addResultListener(ResultListener el) { listener = el; hasListener = listener != null; if (hasListener) { evaluator.addResultListener(el); } }
/** * We just counted number of results: nbResult Just build a Mapping */ void countProfile() { Node n = evaluator.cast(nbResult, memory, producer); Mapping m = Mapping.create(query.getSelectFun().get(0).getNode(), n); results.add(m); }
int compare(Node n1, Node n2) { return evaluator.compare(memory, producer, n1, n2); }
/** * use case: exists {} in aggregate select (count(if (exists { BGP }, ?x, * ?y)) as ?c) Env is a Mapping Copy Mapping into fresh Memory in order to * evaluate exists {} in Memory TODO: optimize by storing mem * * */ public Memory getMemory(Mapping map, Exp exp) { Memory mem = new Memory(match, evaluator); getEvaluator().init(mem); mem.init(query); mem.copy(map, exp); return mem; }
public Object eval(Expr exp, Object[] param){ return evaluator.eval(exp, memory, producer, param); }
void initMemory(Query q) { if (memory == null) { // when subquery, memory is already assigned // assign stack index to EDGE and NODE q.complete(producer);//service while1 / Query memory = new Memory(match, evaluator); memory.setEval(this); getEvaluator().init(memory); // create memory bind stack memory.init(q); if (hasEvent) { memory.setEventManager(manager); } producer.init(q); evaluator.start(memory); debug = q.isDebug(); if (q.isAlgebra()){ complete(q); } if (debug){ System.out.println(q); } } }
@Override public boolean filter() { Expr exp = eval.getEvaluator().getDefineMetadata(getEnvironment(), FILTER, 3); return (exp != null); }
IDatatype funcall(String name, IDatatype[] param, Evaluator eval, Environment env, Producer p) { Function fun = (Function) eval.getDefine(env, name, param.length); if (fun != null) { return call(fun, param, eval, env, p); } return null; }
public IDatatype methodBasic(Eval ev, String name, IDatatype type, IDatatype[] param) { Function exp = (Function) eval.getEvaluator().getDefineMethod(getEnvironment(), name, type, param); if (exp != null) { IDatatype dt = call(exp, param, ev.getEvaluator(), ev.getEnvironment(), ev.getProducer()); return dt; } return null; }
/** * Edge as Function use case: ?x xpath('/book/title') ?y */ private int eval(Node gNode, Exp exp, Stack stack, int n) { int backtrack = n - 1; Edge qEdge = exp.getEdge(); Node qNode = qEdge.getNode(1); Memory env = memory; Evaluator ev = evaluator; Matcher mm = match; for (Node node : ev.evalList(exp.getFilter(), env)) { if (mm.match(qNode, node, env) && env.push(qNode, node)) { backtrack = eval(gNode, stack, n + 1); env.pop(qNode); if (backtrack < n) { // if (hasEvent){ // send(Event.FINISH, exp, gNode, stack); // } return backtrack; } } } return backtrack; }
debug(); evaluator.finish(memory); return results;
/** * copy memory for sub query * copy sub query select variables that are * already bound in current memory * Use case: subquery and exists */ private Memory copyMemory(Memory memory, Query query, Query sub, Exp exp) { Memory mem = new Memory(match, evaluator); getEvaluator().init(mem); if (sub == null) { mem.init(query); } else { mem.init(sub); } memory.copyInto(sub, mem, exp); if (hasEvent) { memory.setEventManager(manager); } return mem; }
/** * 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; }
@Override public boolean filter() { Expr exp = eval.getEvaluator().getDefineMetadata(getEnvironment(), FILTER, 3); return (exp != null); }
IDatatype funcall(String name, IDatatype[] param, Evaluator eval, Environment env, Producer p) { Function fun = (Function) eval.getDefine(env, name, param.length); if (fun != null) { return call(fun, param, eval, env, p); } return null; }
public IDatatype methodBasic(Eval ev, String name, IDatatype type, IDatatype[] param) { Function exp = (Function) eval.getEvaluator().getDefineMethod(getEnvironment(), name, type, param); if (exp != null) { IDatatype dt = call(exp, param, ev.getEvaluator(), ev.getEnvironment(), ev.getProducer()); return dt; } return null; }
void init(Memory env) { mem = new Memory(matcher, evaluator); mem.init(env.getQuery()); mem.init(env); mem.setFake(true); evaluator.init(mem); mem.share(mem.getBind(), env.getBind()); mem.setEval(kgram); }
/** * 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); } } }
boolean define(String name, int arity) { Expr exp = eval.getEvaluator().getDefineMetadata(getEnvironment(), name, arity); return (exp != null); }