try { XQueryEvaluator qe = entry.getValue().load(); qe.setContextItem(sourceRef.get()); XdmValue result = qe.evaluate();
@Override public void process(final InputStream rawIn) throws IOException { try (final InputStream in = new BufferedInputStream(rawIn)) { XQueryEvaluator qe = slashExpression.load(); qe.setSource(new SAXSource(xmlReader, new InputSource(in))); DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance(); dfactory.setNamespaceAware(true); Document dom = dfactory.newDocumentBuilder().newDocument(); qe.run(new DOMDestination(dom)); XdmNode rootNode = proc.newDocumentBuilder().wrap(dom); sourceRef.set(rootNode); } catch (final Exception e) { error.set(e); } } });
xqeval.setDestination(serializer); } else if (outputDest instanceof OutputStream) { ch = new HtmlSerializer((OutputStream) outputDest); xqeval.setDestination(new SAXDestination(ch)); } else if (outputDest instanceof Writer) { ch = new HtmlSerializer((Writer) outputDest); xqeval.setDestination(new SAXDestination(ch)); } else if (outputDest instanceof File) { try { FileOutputStream fos = new FileOutputStream((File) outputDest); ch = new HtmlSerializer(fos); xqeval.setDestination(new SAXDestination(ch)); } catch (FileNotFoundException fnfe) { xqeval.setDestination(serializer); xqeval.setDestination(serializer); xqeval.setDestination(serializer); xqeval.setContextItem(node); xqeval.run();
try { listener.setUserData(this); xqueryEvaluator.setErrorListener(listener); xqueryEvaluator.setContextItem((XdmItem) context.getContextItem()); if (context.getVariableBindings() != null) { for (Map.Entry<QName, Object> binding : context.getVariableBindings().entrySet()) { net.sf.saxon.s9api.QName saxonQName = new net.sf.saxon.s9api.QName(binding.getKey()); xqueryEvaluator.setExternalVariable(saxonQName, (XdmValue) binding.getValue()); XdmValue value = xqueryEvaluator.evaluate(); return new XdmResultSet (value); } catch (SaxonApiException e) { return new XdmResultSet(((TransformErrorListener)xqueryEvaluator.getErrorListener()).getErrors()); } finally { if (docReader != null) {
import javax.xml.parsers.DocumentBuilderFactory; import net.sf.saxon.s9api.*; import org.w3c.dom.Document; ... Document merge(Document context, Document other) throws Exception { Processor processor = new Processor(false); XQueryExecutable executable = processor.newXQueryCompiler().compile( "declare variable $other external; element {node-name(*)} {*/*, $other/*/*}"); XQueryEvaluator evaluator = executable.load(); DocumentBuilder db = processor.newDocumentBuilder(); evaluator.setContextItem(db.wrap(context)); evaluator.setExternalVariable(new QName("other"), db.wrap(other)); Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); processor.writeXdmValue(evaluator.evaluate(), new DOMDestination(doc)); return doc; }
XQueryEvaluator xqeval = xqexec.load(); if (document != null) { xqeval.setContextItem(document); RuntimeValue v = params.get(name); if (runtime.getAllowGeneralExpressions()) { xqeval.setExternalVariable(name, v.getValue()); } else { xqeval.setExternalVariable(name, v.getUntypedAtomic(runtime)); Iterator<XdmItem> iter = xqeval.iterator(); while (iter.hasNext()) { XdmItem item = iter.next();
/** * Set the source document for the query. This method is equivalent to building * a document from the supplied source object, and then supplying the document node of * the resulting document as the initial context node. * @param source the principal source document for the transformation */ public void setSource(Source source) throws SaxonApiException { setContextItem(processor.newDocumentBuilder().build(source)); }
private XQueryEvaluator prepareEvaluation(QueryContext context, TransformErrorListener listener, XQueryExecutable xquery) { listener.setUserData(this); this.queryContext = context; XQueryEvaluator xqueryEvaluator = xquery.load(); xqueryEvaluator.setErrorListener(listener); if (context != null) { xqueryEvaluator.setContextItem((XdmItem) context.getContextItem()); if (context.getVariableBindings() != null) { for (Map.Entry<QName, Object> binding : context.getVariableBindings().entrySet()) { net.sf.saxon.s9api.QName saxonQName = new net.sf.saxon.s9api.QName(binding.getKey()); xqueryEvaluator.setExternalVariable(saxonQName, (XdmValue) binding.getValue()); } } } return xqueryEvaluator; }
/** * Executes a given XQuery expression on the given XML. * @param xml is the XQuery data source * @param query is the query expression * @return with the query result as String * @throws SaxonApiException was thrown when the XQuery execution is failed */ public String evaluateXQuery(final String xml, final String query) throws SaxonApiException { Processor processor = processorFactory.createProcessor(); XQueryCompiler xqueryCompiler = processor.newXQueryCompiler(); xqueryCompiler.setErrorListener(errorListener); XQueryExecutable xqueryExec = xqueryCompiler.compile(query); XQueryEvaluator xqueryEval = xqueryExec.load(); xqueryEval.setErrorListener(errorListener); SAXSource requestXml = saxSourceFactory.createSAXSource(inputSourceFactory.createInputSource(xml)); xqueryEval.setSource(requestXml); ByteArrayOutputStream baos = byteArrayOutputStreamFactory.createByteArrayOutputStream(); Serializer ser = serializerFactory.createSerializer(baos); xqueryEval.setDestination(ser); xqueryEval.run(); return baos.toString(); } }
Processor saxon = new Processor(false); saxon.registerExtensionFunction(new MyExtension()); XQueryCompiler compiler = saxon.newXQueryCompiler(); XQueryExecutable exec = compiler.compile(new File("input/names.xq")); XQueryEvaluator query = exec.load(); DocumentBuilder builder = saxon.newDocumentBuilder(); String students = "<xml>...</xml>"; Source src = new StreamSource(new StringReader(students)); XdmNode doc = builder.build(src); query.setExternalVariable(new QName("student_list"), doc); XdmValue result = query.evaluate();
/** * Evaluates an XQuery 1.0 expression using the Saxon s9api interfaces. * * @param source The XML Source. * @param query The query expression. * @param nsBindings A collection of namespace bindings required to evaluate * the query, where each entry maps a namespace URI (key) to a prefix * (value). * @return An XdmValue object representing a value in the XDM data model. * @throws SaxonApiException If an error occurs while evaluating the query * (this always wraps some other underlying exception). */ public static XdmValue evaluateXQuery(Source source, String query, Map<String, String> nsBindings) throws SaxonApiException { Processor proc = new Processor(false); XQueryCompiler xqCompiler = proc.newXQueryCompiler(); if (null != nsBindings) { for (String nsURI : nsBindings.keySet()) { xqCompiler.declareNamespace(nsBindings.get(nsURI), nsURI); } } XQueryExecutable xqExec = xqCompiler.compile(query); XQueryEvaluator xqEval = xqExec.load(); xqEval.setSource(source); return xqEval.evaluate(); }
try { XQueryExpression e = exp.getUnderlyingCompiledQuery(); SequenceIterator results = e.iterator(evaluator.getUnderlyingQueryContext()); DocumentInfo resultDoc = QueryResult.wrap(results, config); XdmValue wrappedResultDoc = XdmValue.wrap(resultDoc.getUnderlyingNode()); evaluator.runStreamed(input, destination); } else { evaluator.run(destination);
evaluator.run(); try { exp.getUnderlyingCompiledQuery().runUpdate(evaluator.getUnderlyingQueryContext(), agent); } catch (XPathException e) { throw new SaxonApiException(e); if (evaluator.getContextItem() != null) { Set<MutableNodeInfo> affectedDocuments = exp.getUnderlyingCompiledQuery().runUpdate(evaluator.getUnderlyingQueryContext()); Item initial = evaluator.getContextItem().getUnderlyingValue().head(); processor.writeXdmValue(evaluator.getContextItem(), serializer);
@Test public void testEvaluateXQueryShouldCallRun() throws SaxonApiException { //GIVEN in setUp //WHEN underTest.evaluateXQuery(INPUT, QUERY); //THEN verify(xQueryEvaluator).run(); }
Processor proc = new Processor(); XQueryCompiler c = proc.newXQueryCompiler(); XQueryEvaluator q = c.compile($query).load(); List<XdmItem> urls = new ArrayList(); for (url : inputUrls) { urls.append(new XdmAtomicValue(url); } q.setExternalVariable(new QName("urls"), new XdmValue(urls)); q.setDestination(...) run();
for (Map.Entry<String, Object> entry : new Configs().getEntrySet(variables)) { XdmValue xdmValue = XdmNode.wrap(new UntypedAtomicValue(entry.getValue().toString())); evaluator.setExternalVariable(new QName(entry.getKey()), xdmValue); File file = new File(entry.getValue().toString()); XdmValue doc = parseXmlDocument(file); evaluator.setExternalVariable(new QName(entry.getKey()), doc); evaluator.setTraceListener(new XQueryTraceListener()); // TODO redirect from stderr to SLF4J
/** * Set the external variable. The value should be a String. * * @param name Name of the external variable in the XQuery * @param value Value for the external variable */ public void setExternalVariable(String name, String value) { eval.setExternalVariable(new QName(name), new XdmAtomicValue(value)); }
@Override public Sequence call(XPathContext context, Sequence[] arguments) throws XPathException { String query = arguments[0].head().getStringValue(); Evaluator eval = SearchBase.getEvaluator(context); XQueryCompiler xqueryCompiler = eval.getCompiler().getXQueryCompiler(); xqueryCompiler.setErrorListener(eval.getErrorListener()); try { // TODO: cache compiled xslt somewhere XQueryExecutable xqueryExec= xqueryCompiler.compile(query); evaluator = xqueryExec.load(); evaluator.setErrorListener(eval.getErrorListener()); if (arguments.length > 1) { bindParameters(arguments[1]); } XdmValue result = evaluator.evaluate(); ArrayList<TransformerException> runtimeErrors = eval.getErrorListener().getErrors(); if (!runtimeErrors.isEmpty()) { throw new XPathException(runtimeErrors.get(0).getMessage(), runtimeErrors.get(0).getLocator(), runtimeErrors.get(0)); } return result.getUnderlyingValue(); } catch (SaxonApiException e) { throw new XPathException (e); } }
evaluator.setTraceFunctionDestination(traceDestination); if (options.getOptionValue("now") != null) { String now = options.getOptionValue("now"); ConversionResult dt = DateTimeValue.makeDateTimeValue(now, config.getConversionRules()); if (dt instanceof DateTimeValue) { evaluator.getUnderlyingQueryContext().setCurrentDateTime((DateTimeValue) dt); } else { System.err.println("Invalid dateTime: " + now + " (ignored)"); evaluator.setURIResolver(config.makeURIResolver(uriResolverClass));