Node getNode(Expr var, Environment env) { return env.getNode(var); }
private IDatatype test(Producer p, Expr exp, Environment env, IDatatype dt) { IDatatype res = DatatypeMap.createObject("rule", env.getQuery()); return res; }
@Override public IDatatype eval(Expr exp, Environment env, Producer p) { if (env.getEval() == null) { logger.error("Environment getEval() = null in: "); logger.info(exp.toString()); } IDatatype dt = ((Expression) exp).eval(this, (Binding) env.getBind(), env, p); if (dt == null) { DatatypeValue res = env.getVisitor().error(env.getEval(), exp, EMPTY); if (res != null) { return (IDatatype) res; } } return dt; }
IDatatype name(Environment env) { if (env.getGraphNode() == null) { return null; } Node n = env.getNode(env.getGraphNode()); if (n == null) { return null; } return (IDatatype) n.getDatatypeValue(); }
/** * use case: result of st:apply-templates-all() list = list of ?out results * of templates create Mappings (?out = value) apply st:aggregate(?out) on * Mappings Use the st:aggregate of the query q that called * st:apply-templates-all() if q is member of this transformation, otherwise * get the st:profile of this transformation to get the appropriate * st:aggregate definition if any */ IDatatype result(Environment env, List<Node> list) { Query q = (env == null) ? null : env.getQuery(); Query tq = (q != null && contains(q)) ? q : qe.getTemplate(); Memory mem = new Memory(exec.getMatcher(), exec.getEvaluator()); exec.getEvaluator().init(mem); if (env != null){ mem.share(mem.getBind(), env.getBind()); mem.setEval(env.getEval()); } mem.init(tq); Node out = tq.getExtNode(OUT, true); Mappings map = Mappings.create(tq); for (Node node : list) { map.add(Mapping.create(out, node)); } mem.setResults(map); // execute st:aggregate(?out) Node node = map.apply(exec.getEvaluator(), tq.getTemplateGroup(), mem, exec.getProducer()); return (IDatatype) node.getDatatypeValue(); }
Query q = env.getQuery(); Exp pat = q.getPattern(exp); Node gNode = env.getGraphNode(); Memory memory = null; Eval currentEval = getEval(env);
/** * 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); } }
IDatatype eval(String name, IDatatype dt, IDatatype def, Environment env) { if (env != null && env.getQuery() != null) { Query q = env.getQuery(); Extension ext = q.getExtension(); if (ext != null) { Expr function = ext.get(name, (dt == null) ? 0 : 1); if (function != null) { IDatatype dt1 = new Funcall(name).call((Interpreter) exec.getEvaluator(), (Binding) env.getBind(), env, exec.getProducer(), (Function) function, param(dt)); return dt1; } } } return def; }
return DatatypeMap.createObject(env.getMapping()); if (env.getEval() == null) { return null; return DatatypeMap.createObject(env.getEval().getVisitor()); return (IDatatype) env.getVisitor().datatype(param[0], param[1]);
public IDatatype overload(Environment env, IDatatype res, IDatatype... param) { return (IDatatype) env.getVisitor().overload(env.getEval(), this, res, param); }
/** * Create a unique BN ID according to (Rule, qNode & Mapping) If the rule * runs twice on same mapping, it will create same BN graph will detect it, * hence engine will not loop * */ String blankRule(Node qNode, Environment map) { // _:b + rule ID + "." + qNode ID StringBuffer sb = new StringBuffer(root); sb.append(getIndex(qNode)); for (Node qnode : map.getQueryNodes()) { if (qnode != null && qnode.isVariable() && !qnode.isBlank()) { // node value ID sb.append(DOT); sb.append(map.getNode(qnode).getIndex()); } } return sb.toString(); }
Node qNode = env.getQueryNode(exp.getExp(0).getLabel()); if (qNode == null) { return null; int value = env.pathWeight(qNode); return proxy.getValue(value);
Path getPath(Expr exp, Environment env){ Node qNode = env.getQueryNode(exp.getExp(0).getLabel()); if (qNode == null) { return null; } Path p = env.getPath(qNode); return p; }
IDatatype dt; for (Mapping map : env.getAggregate()) { env.aggregate(map, n++); map.setEval(env.getEval()); if (map.getBind() == null) {