org.apache.jena.sparql.expr.ExprList Java Examples

private static Node invokeFunction(Resource function, ExprList args, Dataset dataset) {

		if (dataset == null) {
	        dataset = ARQFactory.get().getDataset(ModelFactory.createDefaultModel());
	    }
		
		E_Function expr = new E_Function(function.getURI(), args);
		DatasetGraph dsg = dataset.asDatasetGraph();
		Context cxt = ARQ.getContext().copy();
		cxt.set(ARQConstants.sysCurrentTime, NodeFactoryExtra.nowAsDateTime());
		FunctionEnv env = new ExecutionContext(cxt, dsg.getDefaultGraph(), dsg, null);
		try {
			NodeValue r = expr.eval(BindingRoot.create(), env);
			if(r != null) {
				return r.asNode();
			}
		}
		catch(ExprEvalException ex) {
		}
		return null;
	}
 

@Override
public NodeValue exec(Binding binding, ExprList args, String uri, FunctionEnv env) {
    if (args == null) {
        throw new ARQInternalErrorException("FunctionBase: Null args list");
    }
    if (args.size() != 0) {
        throw new ExprEvalException("Expecting zero argument");
    }
    IndentedWriter writer = ContextUtils.getTemplateOutput(env.getContext());
    if(writer != null) {
    	writer.decIndent();
    } else {
    	LOG.warn("calling st:decr() outside TEMPLATE context.");
    }
    return EMPTY_NODE;
}
 

@Override
public NodeValue exec(Binding binding, ExprList args, String uri, FunctionEnv env) {
    if (args == null) {
        throw new ARQInternalErrorException("FunctionBase: Null args list");
    }
    if (args.size() != 0) {
        throw new ExprEvalException("Expecting zero argument");
    }
    IndentedWriter writer = ContextUtils.getTemplateOutput(env.getContext());
    if(writer != null) {
    	writer.incIndent();
    } else {
    	LOG.warn("calling st:incr() outside TEMPLATE context.");
    }
    return EMPTY_NODE;
}
 

/**
 * 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 NodeValue exec(Binding binding, ExprList args, String uri, FunctionEnv env) {
    if (args == null) {
        throw new ARQInternalErrorException("FunctionBase: Null args list");
    }
    if (args.size() != 2) {
        throw new ExprEvalException("Expecting two argument");
    }
    NodeValue file = args.get(0).eval(binding, env);
    NodeValue propertyNode = args.get(1).eval(binding, env);
    if (!propertyNode.isString()) {
        throw new ExprEvalException("Second argument must be a string. Got " + propertyNode);
    }
    Properties properties;
    try {
        properties = getProperties(file, env);
    } catch (IOException ex) {
        throw new ExprEvalException("IOException while extracting properties document " + file, ex);
    }
    String prop = properties.getProperty(propertyNode.getString());
    if (prop == null) {
        throw new ExprEvalException("Property " + prop + " not found in properties document " + file);
    }
    return new NodeValueString(prop);
}
 

@Override
public void visit(ElementBox el) {
    final List<Expr> texprs = new ArrayList<>();
    texprs.add(new E_Function(ST.incr, new ExprList()));
    List<Element> elements = el.getTExpressions();
    for (int i = 0; i < elements.size(); i++) {
        elements.get(i).visit(this);
        if (result instanceof E_Function && ((E_Function) result).getFunctionIRI().equals(ST.concat)) {
            texprs.addAll(((E_Function) result).getArgs());
        } else {
            texprs.add(result);
        }
    }
    texprs.add(new E_Function(ST.decr, new ExprList()));
    result = new E_Function(ST.concat, new ExprList(texprs));
}
 

@Override
public final void exec(
        final Binding binding,
        final ExprList args,
        final FunctionEnv env,
        final Consumer<List<List<NodeValue>>> collectionListNodeValue) {

    this.env = env;
    if (args == null) {
        throw new ARQInternalErrorException("IteratorFunctionBase:"
                + " Null args list");
    }

    List<NodeValue> evalArgs = new ArrayList<>();
    for (Expr e : args) {
        try {
            NodeValue x = e.eval(binding, env);
            evalArgs.add(x);
        } catch (ExprEvalException ex) {
            LOG.trace("Cannot evaluate node " + e + ": " + ex.getMessage());
            evalArgs.add(null);
        }
    }
    exec(evalArgs, collectionListNodeValue);
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 3) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes three arguments");
    }
}
 

private void normalizeCallParams(ExprNormalizer enzer, SPARQLExtQuery query) {
    if (query.hasName()) {
        query.setName(enzer.normalize(query.getName()));
    }
    if (query.hasCallParameters()) {
        final List<Expr> parameters = query.getCallParameters().getList();
        final List<Expr> nzed = new ArrayList<>();
        parameters.forEach((p) -> {
            nzed.add(enzer.normalize(p));
        });
        query.setCallParameters(new ExprList(nzed));
    }
}
 

private Expr normalize(ExprFunctionN func) {
    ExprList args = new ExprList();
    for (Expr expr : func.getArgs()) {
        Expr arg = normalize(expr);
        args.add(arg);
    }
    return func.copy(args);
}
 

@Override
public void checkBuild(ExprList args) {
    if (args.size() != 1 && args.size() != 2) {
        throw new QueryBuildException("Function '"
                + this.getClass().getName() + "' takes two arguments: (1) "
                + "the server URI to connect to, (2) the message to be sent to"
                + " the server (e.g., a json query).");
    }
}
 

@Override
public NodeValue exec(Binding binding, ExprList args, String uri, FunctionEnv env) {
    final boolean isDebugStConcat = ContextUtils.isDebugStConcat(env.getContext());
    if (args == null) // The contract on the function interface is that this should not happen.
    {
        throw new ARQInternalErrorException("FunctionBase: Null args list");
    }

    List<NodeValue> evalArgs = new ArrayList<>();
    for (Expr e : args) {
        try {
            NodeValue x = e.eval(binding, env);
            evalArgs.add(x);
        } catch (Exception ex) {
            StringWriter sw = new StringWriter();
            ex.printStackTrace(new PrintWriter(sw));
            String message = String.format("Error executing st:format with expression %s and binding %s: %s", ExprUtils.fmtSPARQL(args), LogUtils.compress(binding).toString(), sw.toString());
            if (LOG.isDebugEnabled()) {
                LOG.debug(message, ex);
            }
            if (isDebugStConcat) {
                evalArgs.add(new NodeValueString(String.format("\n<<<<<<<<<< %s >>>>>>>>>>\n", message)));
            }
        }
    }

    NodeValue nv = exec(evalArgs, env);
    return nv;
}
 

@Override
public void visit(ElementFormat el) {
    final List<Expr> texprs = new ArrayList<>();
    texprs.add(el.getExpr().getExpr());
    el.getTExpressions().forEach((e) -> {
        e.visit(this);
        texprs.add(result);
    });
    result = new E_Function(ST.format, new ExprList(texprs));
}
 

public static List<List<Node>> eval(
        final ExprList exprs,
        final List<Binding> bindings,
        final FunctionEnv env) {
    final List<List<Node>> nodesList = new ArrayList<>();
    for (Binding binding : bindings) {
        List<Node> nodes = eval(exprs, binding, env);
        if (nodes != null) {
            nodesList.add(nodes);
        }
    }
    return nodesList;
}
 

public static List<Node> eval(
        final ExprList exprs,
        final Binding binding,
        final FunctionEnv env) {
    Objects.requireNonNull(binding);
    Objects.requireNonNull(env);
    if (exprs == null) {
        return null;
    }
    final List<Node> nodes = new ArrayList<>();
    exprs.forEach((expr) -> {
        nodes.add(eval(expr, binding, env));
    });
    return nodes;
}
 

public static void fmtSPARQL(IndentedWriter iOut, ExprList exprs, SerializationContext pmap) {
    SPARQLExtFmtExprSPARQL fmt = new SPARQLExtFmtExprSPARQL(iOut, pmap);
    String sep = "";
    for (Expr expr : exprs) {
        iOut.print(sep);
        sep = " , ";
        fmt.format(expr);
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 1) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes one argument");
    }
}
 

@Override
public NodeValue exec(Binding binding, ExprList args, String uri, FunctionEnv env) {
	if (args == null) {
		throw new ARQInternalErrorException("ExpandPrefixFunction: Null args list");
	}
	if (args.size() != 1) {
		throw new ExprEvalException("ExpandPrefixFunction: Wrong number of arguments: Wanted 1, got " + args.size());
	}
       return exec(args.get(0).eval(binding, env), env.getContext());
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 0) {
        throw new QueryBuildException("Iterator function '"
                + this.getClass().getName() + "' takes no arguments");
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 1) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes one argument");
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 5) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes 5 arguments");
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (!args.isEmpty()) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes zero arguments");
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 2) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes two arguments");
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 5) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes 5 arguments");
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 4) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes 4 arguments");
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 2) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes two arguments");
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void checkBuild(ExprList args) {
    if (args.size() != 3) {
        throw new QueryBuildException("Selector '"
                + this.getClass().getName() + "' takes three arguments");
    }
}
 

public static Node invokeFunction3(Resource function, RDFNode argument1, RDFNode argument2, RDFNode argument3, Dataset dataset) {
	ExprList args = new ExprList();
	args.add(argument1 != null ? NodeValue.makeNode(argument1.asNode()) : new ExprVar("arg1"));
	args.add(argument2 != null ? NodeValue.makeNode(argument2.asNode()) : new ExprVar("arg2"));
	args.add(argument3 != null ? NodeValue.makeNode(argument3.asNode()) : new ExprVar("arg3"));
	return invokeFunction(function, args, dataset);
}
 

/** Function called on each row in a group */
@Override
public void accumulate(Binding binding, FunctionEnv functionEnv) {
    ExprList exprList = agg.getExprList() ;
    for(Expr expr: exprList) {
        try {
            NodeValue nv = expr.eval(binding, functionEnv) ;
            // Evaluation succeeded.
            if ( nv.isLiteral())
                count ++ ;
        } catch (ExprEvalException ex) {}
    }
}
 

@Override
public NodeValue exec(Binding binding, ExprList args, String uri, FunctionEnv env) {
	if (args == null) {
		throw new ARQInternalErrorException("ExpandPrefixFunction: Null args list");
	}
	if (args.size() != 1) {
		throw new ExprEvalException("ExpandPrefixFunction: Wrong number of arguments: Wanted 1, got " + args.size());
	}
       return exec(args.get(0).eval(binding, env), env.getContext());
}