Java XQueryExpression类代码示例

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
@Override
public boolean isQueryReadOnly(final String query, Properties props) throws XQException {
	boolean result = super.isQueryReadOnly(query);
	if (result) {
		int qKey = getQueryManagement().getQueryKey(query);
		XQueryExpression xqExp;
		try {
			xqExp = getXQuery(qKey, query, props);
		} catch (XPathException xpe) {
        	logger.error("isQueryReadOnly.error: ", xpe);
       		throw convertXPathException(xpe);
		}
		result = !isUpdatingExpression(xqExp.getExpression());
  	    }
  	    return result;
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
private XQueryExpression getXQuery(int queryKey, String query, Properties props) throws XPathException, XQException {
    XQueryExpression xqExp = queries.get(queryKey);
	if (xqExp == null) {
		if (props != null) {
			setStaticContext(sqc, props);
		}
   	    sqc.setModuleURIResolver(config.getModuleURIResolver());
     xqExp = sqc.compileQuery(query);
     if (logger.isTraceEnabled()) {
     	logger.trace("getXQuery; query: \n{}; \nexpression: {}", explainQuery(xqExp), 
     			xqExp.getExpression().getExpressionName());
     }
    	queries.put(queryKey, xqExp);
	} 
	return xqExp;
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
private XQueryExpression getModuleExpression(Module module) throws BagriException {
	//logger.trace("getModuleExpression.enter; got namespace: {}, name: {}, body: {}", namespace, name, body);
	String query = "import module namespace test=\"" + module.getNamespace() + 
			"\" at \"" + module.getName() + "\";\n\n1213";
	StaticQueryContext sqc = null;
	try {
		//sqc.compileLibrary(query); - works in Saxon-EE only
	    sqc = prepareStaticContext(module.getBody());
		logger.trace("getModuleExpression; compiling query: {}", query);
		//logger.trace("getModuleExpression.exit; time taken: {}", stamp);
		return sqc.compileQuery(query);
		//sqc.getCompiledLibrary("test")...
	} catch (XPathException ex) {
		String error = getError(ex, sqc);
		logger.error("getModuleExpression.error; " + error, ex);
		//logger.info("getModuleExpression.error; message: {}", error);
		throw new BagriException(error, BagriException.ecQueryCompile);
	}
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
public Collection<String> prepareXQuery(String query, XQStaticContext ctx) throws XQException {

        setStaticContext(sqc, ctx);
        try {
	        final XQueryExpression exp = sqc.compileQuery(query);
	        if (logger.isTraceEnabled()) {
	        	logger.trace("prepareXQuery; query: \n{}", explainQuery(exp));
	        }
	        
	        Set<String> result = new HashSet<>();
	        Iterator<GlobalVariable> itr = exp.getMainModule().getModuleVariables();
	        while (itr.hasNext()) {
	        	result.add(itr.next().getVariableQName().getClarkName());
	        }
	        return result; 
        } catch (XPathException ex) {
        	logger.error("prepareXQuery.error: ", ex);
        	throw new XQException(ex.getMessage());
        }
    }
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
@Test
public void testPersonQuery() throws XPathException, XQException {

       Configuration config = Configuration.newConfiguration();
       StaticQueryContext sqc = config.newStaticQueryContext();
  	    DynamicQueryContext dqc = new DynamicQueryContext(config);
       dqc.setApplyFunctionConversionRulesToExternalVariables(false);

	String query = "declare base-uri \"../../etc/samples/xmark/\";\n" +
			"let $auction := fn:doc(\"auction.xml\") return\n" +
			"for $b in $auction/site/people/person[@id = 'person0'] return $b/name/text()";
  	    
	//dqc.setParameter(new StructuredQName("", "", "v"), objectToItem(Boolean.TRUE, config));
  	    XQueryExpression xqExp = sqc.compileQuery(query);
       SequenceIterator itr = xqExp.iterator(dqc);
       Item item = itr.next();
  	    assertNotNull(item);
  	    String val = item.getStringValue();
	assertEquals("Huei Demke", val);
	assertNull(itr.next());
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
@Test
public void testCollationQuery() throws XPathException {
       Configuration config = Configuration.newConfiguration();
       StaticQueryContext sqc = config.newStaticQueryContext();
       // this causes Saxon throw NPE and query processing!
       //sqc.declareDefaultCollation("");
  	    DynamicQueryContext dqc = new DynamicQueryContext(config);
       dqc.setApplyFunctionConversionRulesToExternalVariables(false);

	String query = "declare base-uri \"../../etc/samples/xmark/\";\n" +
			"let $auction := fn:doc(\"auction.xml\") return\n" +
			"for $i in $auction/site//item\n" +
			"where contains(string(exactly-one($i/description)), \"gold\")\n" +
			"return $i/name/text()";
			
  	    XQueryExpression xqExp = sqc.compileQuery(query);
       SequenceIterator itr = xqExp.iterator(dqc);
       Item item = itr.next();
  	    assertNotNull(item);
  	    assertNotNull(item.getStringValue());
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
/**
 * Creates list variable of resulting XML nodes.
 * @param exp
 * @param dynamicContext
 * @return
 * @throws XPathException
 */
public static ListVariable createListOfXmlNodes(XQueryExpression exp, DynamicQueryContext dynamicContext) throws XPathException {
    final SequenceIterator iter = exp.iterator(dynamicContext);

    ListVariable listVariable = new ListVariable();
    while (true) {
        Item item = iter.next();
        if (item == null) {
            break;
        }

        XmlNodeWrapper value = new XmlNodeWrapper(item);
        listVariable.addVariable( new NodeVariable(value) );
    }

    return listVariable;
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
public static XQueryBuilder xquery(final String queryText) {
    return new XQueryBuilder() {
        protected XQueryExpression createQueryExpression(StaticQueryContext staticQueryContext)
            throws XPathException {
            return staticQueryContext.compileQuery(queryText);
        }
    };
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
private Iterator<Object> execQuery(final String query) throws XQException {
    logger.trace("execQuery.enter; this: {}", this);
	long stamp = System.currentTimeMillis();
  	    
  	    QueryManagement qMgr = (QueryManagement) getQueryManagement();
  	    Query xQuery = qMgr.getQuery(query);
    Integer qKey = qMgr.getQueryKey(query);
  	    try {
  	   	    XQueryExpression xqExp = getXQuery(qKey, query, null);
       	Map<String, Object> params = getObjectParams();
   	    if (xQuery == null) {
        	clnFinder.setQuery(null);
        } else {
   	    	QueryBuilder xdmQuery = xQuery.getXdmQuery();
   	    	if (!(params == null || params.isEmpty())) {
       	    	xdmQuery.resetParams(params);
   	    	}
    		clnFinder.setQuery(xdmQuery);
   	    }
       	clnFinder.setExpression(xqExp);

        stamp = System.currentTimeMillis() - stamp;
	    logger.trace("execQuery; xQuery: {}; params: {}; time taken: {}", xQuery, params, stamp);
	    stamp = System.currentTimeMillis();
        SequenceIterator itr = xqExp.iterator(dqc);
        //Result r = new StreamResult();
        //xqExp.run(dqc, r, null);
        stamp = System.currentTimeMillis() - stamp;
	    logger.trace("execQuery.exit; time taken: {}", stamp);
        return new XQIterator(getXQDataFactory(), itr); 
       } catch (XPathException xpe) {
       	logger.error("execQuery.error: ", xpe);
       	throw convertXPathException(xpe);
       }
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
protected String explainQuery(XQueryExpression exp) throws XPathException {
  	ByteArrayOutputStream baos = new ByteArrayOutputStream();
  	PrintStream ps = new PrintStream(baos);
  	Logger log = new StandardLogger(ps);
      exp.getExpression().explain(log);
      String res = new String(baos.toByteArray(), Charset.defaultCharset());
      log.close();
      ps.close();
      try {
	baos.close();
} catch (IOException ex) {
	throw new XPathException(ex);
}
      return res;
  }
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
public void parseXQuery(String query) throws XQException {

        try {
	        final XQueryExpression exp = sqc.compileQuery(query);
	        // why do we do this? to populate dqc with params??
	        List results = exp.evaluate(dqc);
	        for (Object result: results) {
	            logger.trace("result: {}; class: {}", result, result.getClass().getName());
	        }
        } catch (XPathException ex) {
        	logger.error("parseXQuery.error: ", ex);
        	throw new XQException(ex.getMessage());
        }
    }
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
@Test
public void testMapQuery() throws XPathException {
       Configuration config = Configuration.newConfiguration();
       config.setDefaultCollection("");
       StaticQueryContext sqc = config.newStaticQueryContext();
  	    DynamicQueryContext dqc = new DynamicQueryContext(config);
       dqc.setApplyFunctionConversionRulesToExternalVariables(false);

       //String xml = "<map>\n" +
       //		"  <boolProp>false</boolProp>\n" +
       //		"  <strProp>XYZ</strProp>\n" +
       //		"  <intProp>1</intProp>\n" +
       //		"</map>";
   	//String baseURI = sqc.getBaseURI(); 
       //StringReader sr = new StringReader(xml);
       //InputSource is = new InputSource(sr);
       //is.setSystemId(baseURI);
       //Source source = new SAXSource(is);
       //source.setSystemId(baseURI);
       //config.getGlobalDocumentPool().add(config.buildDocumentTree(source), "map.xml");
       
	String query = "declare base-uri \"../../etc/samples/xdm/\";\n" +
			"declare variable $value external;\n" +
			"for $doc in fn:collection()/map\n" +
			"where $doc/intProp = $value\n" +
			//"where $doc[intProp = $value]\n" +
			"return $doc/strProp/text()";
       
  	    XQueryExpression xqExp = sqc.compileQuery(query);
  	    dqc.setParameter(new StructuredQName("", "", "value"), objectToItem(1, config));
       SequenceIterator itr = xqExp.iterator(dqc);
       Item item = itr.next();
  	    assertNotNull(item);
  	    String val = item.getStringValue();
	assertEquals("XYZ", val);
	assertNull(itr.next());
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
@Test
@Ignore
public void testJsonQuery() throws XPathException {
       Configuration config = Configuration.newConfiguration();
       config.setDefaultCollection("");
       StaticQueryContext sqc = config.newStaticQueryContext();
	sqc.setLanguageVersion(saxon_xquery_version); 
  	    DynamicQueryContext dqc = new DynamicQueryContext(config);
       dqc.setApplyFunctionConversionRulesToExternalVariables(false);

	String query = "declare base-uri \"../../etc/samples/json/\";\n" +
			//"declare base-uri \"C:/Work/Bagri/git/bagri/etc/samples/json/\";\n" +
			"declare namespace map=\"http://www.w3.org/2005/xpath-functions/map\";\n" +
			//"declare variable $value external;\n" +
			"for $map in fn:collection()\n" +
			//"where $map?Security?Symbol = $value\n" +
			"let $v := map:get($map, 'Security')\n" +
			//"where get($map, '-id') = '5621'\n" +
			"where map:get($v, 'Symbol') = 'IBM'\n" +
			"return $v?Name";
       
  	    XQueryExpression xqExp = sqc.compileQuery(query);
  	    //dqc.setParameter(new StructuredQName("", "", "value"), objectToItem("IBM", config));
       SequenceIterator itr = xqExp.iterator(dqc);
       Item item = itr.next();
  	    assertNotNull(item);
  	    String val = item.getStringValue();
	assertEquals("Internatinal Business Machines Corporation", val);
	assertNull(itr.next());
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
public final Sequence callXQueryFunction (String filename, String namespaceURI, String functionName, Sequence[] args) throws XQueryException {
    Sequence[] actualArgs = (args == null) ? new Sequence[] {} : args;
    try {
        StaticQueryContext sqc = this.processor.getUnderlyingConfiguration().newStaticQueryContext();
        XQueryExpression exp = sqc.compileQuery(fromResource(filename));
        int numOfArgs = (args == null) ? 0 : args.length;
        UserFunction function = exp.getStaticContext().getUserDefinedFunction(namespaceURI, functionName, numOfArgs);
        return function.call(actualArgs, exp.newController());
    }
    catch (XPathException | IOException e) {
        throw new XQueryException("Unable to call function " + namespaceURI + ":" + functionName, e);
    }
}
 

import net.sf.saxon.query.XQueryExpression; //导入依赖的package包/类
/**
 * Evaluates specified XPath expression against given XML text and using given runtime configuration.
 * @param xpath
 * @param xml
 * @param runtimeConfig
 * @return Instance of ListVariable that contains results.
 * @throws XPathException
 */
public static ListVariable evaluateXPath(String xpath, String xml, RuntimeConfig runtimeConfig) throws XPathException {
    StaticQueryContext sqc = runtimeConfig.getStaticQueryContext();
    Configuration config = sqc.getConfiguration();

    XQueryExpression exp = runtimeConfig.getXQueryExpressionPool().getCompiledExpression(xpath);
    DynamicQueryContext dynamicContext = new DynamicQueryContext(config);
    StringReader reader = new StringReader(xml);

    dynamicContext.setContextItem(sqc.buildDocument(new StreamSource(reader)));

    return createListOfXmlNodes(exp, dynamicContext);
}