/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.ode.bpel.elang.xquery10.runtime;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URI;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import javax.xml.namespace.QName;
import javax.xml.transform.TransformerFactory;
import javax.xml.xpath.XPathConstants;
import javax.xml.xquery.XQConnection;
import javax.xml.xquery.XQConstants;
import javax.xml.xquery.XQDataSource;
import javax.xml.xquery.XQException;
import javax.xml.xquery.XQItem;
import javax.xml.xquery.XQItemType;
import javax.xml.xquery.XQPreparedExpression;
import javax.xml.xquery.XQResultSequence;
import javax.xml.xquery.XQSequence;
import javax.xml.xquery.XQSequenceType;
import javax.xml.xquery.XQStaticContext;
import net.sf.saxon.Configuration;
import net.sf.saxon.om.Item;
import net.sf.saxon.om.Validation;
//import net.sf.saxon.trans.DynamicError;
import net.sf.saxon.trans.XPathException;
import net.sf.saxon.value.DurationValue;
import net.sf.saxon.value.Value;
import net.sf.saxon.xqj.SaxonXQConnection;
import net.sf.saxon.xqj.SaxonXQDataSource;
import net.sf.saxon.xqj.SaxonXQItem;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ode.bpel.common.FaultException;
import org.apache.ode.bpel.elang.xpath20.compiler.Constants;
import org.apache.ode.bpel.elang.xpath20.compiler.WrappedResolverException;
import org.apache.ode.bpel.elang.xpath20.runtime.JaxpFunctionResolver;
import org.apache.ode.bpel.elang.xpath20.runtime.JaxpVariableResolver;
import org.apache.ode.bpel.elang.xquery10.compiler.XQuery10BpelFunctions;
import org.apache.ode.bpel.elang.xquery10.o.OXQuery10ExpressionBPEL20;
import org.apache.ode.bpel.explang.ConfigurationException;
import org.apache.ode.bpel.explang.EvaluationContext;
import org.apache.ode.bpel.explang.EvaluationException;
import org.apache.ode.bpel.explang.ExpressionLanguageRuntime;
import org.apache.ode.bpel.o.OExpression;
import org.apache.ode.utils.DOMUtils;
import org.apache.ode.utils.ISO8601DateParser;
import org.apache.ode.utils.NSContext;
import org.apache.ode.utils.xsd.Duration;
import org.apache.ode.utils.xsl.XslTransformHandler;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
/**
* XQuery 1.0 Expression Language run-time subsytem. Saxon implementation.
*/
@SuppressWarnings("deprecation")
public class XQuery10ExpressionRuntime implements ExpressionLanguageRuntime {
static final short NODE_TYPE = 1;
static final short NODESET_TYPE = 2;
static final short STRING_TYPE = 3;
static final short BOOLEAN_TYPE = 4;
static final short NUMBER_TYPE = 5;
/** Class-level logger. */
private static final Log __log = LogFactory.getLog(XQuery10ExpressionRuntime.class);
/**
* Creates a new XQuery10ExpressionRuntime object.
*/
public XQuery10ExpressionRuntime() {
}
/**
* Initialize XSL Transformer
*
* @param properties properties
*
* @throws ConfigurationException ConfigurationException
*/
public void initialize(Map properties) throws ConfigurationException {
TransformerFactory trsf = new net.sf.saxon.TransformerFactoryImpl();
XslTransformHandler.getInstance().setTransformerFactory(trsf);
}
/**
*
* @see org.apache.ode.bpel.explang.ExpressionLanguageRuntime#evaluateAsString(org.apache.ode.bpel.o.OExpression,
* org.apache.ode.bpel.explang.EvaluationContext)
*/
public String evaluateAsString(OExpression cexp, EvaluationContext ctx)
throws FaultException, EvaluationException {
return (String) evaluate(cexp, ctx, XPathConstants.STRING);
}
/**
*
* @see org.apache.ode.bpel.explang.ExpressionLanguageRuntime#evaluateAsBoolean(org.apache.ode.bpel.o.OExpression,
* org.apache.ode.bpel.explang.EvaluationContext)
*/
public boolean evaluateAsBoolean(OExpression cexp, EvaluationContext ctx)
throws FaultException, EvaluationException {
return (Boolean) evaluate(cexp, ctx, XPathConstants.BOOLEAN);
}
/**
* Evaluate expression and return a number
*
* @param cexp cexp
* @param ctx ctx
*
* @return type
*
* @throws FaultException FaultException
* @throws EvaluationException EvaluationException
*/
public Number evaluateAsNumber(OExpression cexp, EvaluationContext ctx)
throws FaultException, EvaluationException {
return (Number) evaluate(cexp, ctx, XPathConstants.NUMBER);
}
/**
*
* @see org.apache.ode.bpel.explang.ExpressionLanguageRuntime#evaluate(org.apache.ode.bpel.o.OExpression,
* org.apache.ode.bpel.explang.EvaluationContext)
*/
public List evaluate(OExpression cexp, EvaluationContext ctx)
throws FaultException, EvaluationException {
List result;
Object someRes = evaluate(cexp, ctx, XPathConstants.NODESET);
if (someRes instanceof List) {
result = (List) someRes;
if (__log.isDebugEnabled()) {
__log.debug("Returned list of size " + result.size());
}
if ((result.size() == 1) && !(result.get(0) instanceof Node)) {
// Dealing with a Java class
Object simpleType = result.get(0);
// Dates get a separate treatment as we don't want to call toString on them
String textVal;
if (simpleType instanceof Date) {
textVal = ISO8601DateParser.format((Date) simpleType);
} else if (simpleType instanceof DurationValue) {
textVal = ((DurationValue) simpleType).getStringValue();
} else {
textVal = simpleType.toString();
}
// Wrapping in a document
Document d = DOMUtils.newDocument();
// Giving our node a parent just in case it's an LValue expression
Element wrapper = d.createElement("wrapper");
Text text = d.createTextNode(textVal);
wrapper.appendChild(text);
d.appendChild(wrapper);
result = Collections.singletonList(text);
}
} else if (someRes instanceof NodeList) {
NodeList retVal = (NodeList) someRes;
if (__log.isDebugEnabled()) {
__log.debug("Returned node list of size " + retVal.getLength());
}
result = new ArrayList(retVal.getLength());
for (int m = 0; m < retVal.getLength(); ++m) {
Node val = retVal.item(m);
if (val.getNodeType() == Node.DOCUMENT_NODE) {
val = ((Document) val).getDocumentElement();
}
result.add(val);
}
} else {
result = null;
}
return result;
}
/**
* Evaluate expression and return a node
*
* @param cexp cexp
* @param ctx ctx
*
* @return type
*
* @throws FaultException FaultException
* @throws EvaluationException EvaluationException
*/
public Node evaluateNode(OExpression cexp, EvaluationContext ctx)
throws FaultException, EvaluationException {
List retVal = evaluate(cexp, ctx);
if (retVal.size() == 0) {
throw new FaultException(cexp.getOwner().constants.qnSelectionFailure,
"No results for expression: " + cexp);
}
if (retVal.size() > 1) {
throw new FaultException(cexp.getOwner().constants.qnSelectionFailure,
"Multiple results for expression: " + cexp);
}
return (Node) retVal.get(0);
}
/**
* Evaluate expression and return a date
*
* @param cexp cexp
* @param context context
*
* @return type
*
* @throws FaultException FaultException
* @throws EvaluationException EvaluationException
*/
public Calendar evaluateAsDate(OExpression cexp, EvaluationContext context)
throws FaultException, EvaluationException {
List literal = DOMUtils.toList(evaluate(cexp, context,
XPathConstants.NODESET));
if (literal.size() == 0) {
throw new FaultException(cexp.getOwner().constants.qnSelectionFailure,
"No results for expression: " + cexp);
}
if (literal.size() > 1) {
throw new FaultException(cexp.getOwner().constants.qnSelectionFailure,
"Multiple results for expression: " + cexp);
}
Object date = literal.get(0);
if (date instanceof Calendar) {
return (Calendar) date;
}
if (date instanceof Date) {
Calendar cal = Calendar.getInstance();
cal.setTime((Date) date);
return cal;
}
if (date instanceof Element) {
date = ((Element) date).getTextContent();
}
try {
return ISO8601DateParser.parseCal(date.toString());
} catch (Exception ex) {
String errmsg = "Invalid date: " + literal;
__log.error(errmsg, ex);
throw new FaultException(cexp.getOwner().constants.qnInvalidExpressionValue,
errmsg);
}
}
/**
* Evaluate expression and return duration
*
* @param cexp cexp
* @param context context
*
* @return type
*
* @throws FaultException FaultException
* @throws EvaluationException EvaluationException
*/
public Duration evaluateAsDuration(OExpression cexp,
EvaluationContext context) throws FaultException, EvaluationException {
String literal = this.evaluateAsString(cexp, context);
try {
return new Duration(literal);
} catch (Exception ex) {
String errmsg = "Invalid duration: " + literal;
__log.error(errmsg, ex);
throw new FaultException(cexp.getOwner().constants.qnInvalidExpressionValue,
errmsg);
}
}
/**
* Evaluate expression and return opaque type
*
* @param cexp cexp
* @param ctx ctx
* @param type type
*
* @return type
*
* @throws FaultException FaultException
* @throws EvaluationException EvaluationException
*/
private Object evaluate(OExpression cexp, EvaluationContext ctx, QName type)
throws FaultException, EvaluationException {
try {
OXQuery10ExpressionBPEL20 oxquery10 = ((OXQuery10ExpressionBPEL20) cexp);
XQDataSource xqds = new SaxonXQDataSource();
XQConnection xqconn = xqds.getConnection();
Configuration configuration = ((SaxonXQConnection) xqconn).getConfiguration();
//configuration.setAllNodesUntyped(true);
configuration.setHostLanguage(Configuration.XQUERY);
XQStaticContext staticEnv = xqconn.getStaticContext();
NSContext nsContext = oxquery10.namespaceCtx;
Set<String> prefixes = nsContext.getPrefixes();
for (String prefix : prefixes) {
String uri = nsContext.getNamespaceURI(prefix);
staticEnv.declareNamespace(prefix, uri);
}
configuration.setSchemaValidationMode(Validation.SKIP);
xqconn.setStaticContext(staticEnv);
// Prepare expression, for starters
String xquery = oxquery10.xquery.replaceFirst(
Constants.XQUERY_FUNCTION_HANDLER_COMPILER,
Constants.XQUERY_FUNCTION_HANDLER_RUNTIME);
XQPreparedExpression exp = xqconn.prepareExpression(xquery);
JaxpFunctionResolver funcResolver = new JaxpFunctionResolver(ctx,
oxquery10);
JaxpVariableResolver variableResolver = new JaxpVariableResolver(ctx,
oxquery10, configuration);
// Bind external variables to runtime values
for (QName variable : exp.getAllUnboundExternalVariables()) {
// Evaluate referenced variable
Object value = variableResolver.resolveVariable(variable);
if (value instanceof Value) {
SaxonXQConnection saxonConn = (SaxonXQConnection) xqconn;
try {
Item item = ((Value) value).asItem();
if (item == null) {
exp.bindSequence(variable, xqconn.createSequence(Collections.EMPTY_LIST.iterator()));
} else {
XQItem item2 = new SaxonXQItem(item, saxonConn);
exp.bindItem(variable, item2);
}
} catch (XPathException e) {
__log.warn("", e);
}
} else {
if (value instanceof Date) {
Date d = (Date) value;
value = org.apache.ode.utils.ISO8601DateParser.format(d);
}
// Figure out type of variable
XQSequenceType xqType = getItemType(xqconn, value);
// Saxon doesn't like binding sequences to variables
if (value instanceof Node) {
// a node is a node-list, but the inverse isn't true.
// so, if the value is truly a node, leave it alone.
} else if (value instanceof NodeList) {
// So extract the first item from the node list
NodeList nodeList = (NodeList) value;
ArrayList nodeArray = new ArrayList();
for (int i = 0; i < nodeList.getLength(); i++) {
nodeArray.add(nodeList.item(i));
}
value = xqconn.createSequence(nodeArray.iterator());
}
// Bind value with external variable
if (value != null && xqType != null) {
if (value instanceof XQSequence) {
exp.bindSequence(variable, (XQSequence) value);
} else {
if (xqType instanceof XQItemType) {
exp.bindObject(variable, value, (XQItemType) xqType);
}
}
}
}
}
// Set context node
Node contextNode = (ctx.getRootNode() == null)
? DOMUtils.newDocument() : ctx.getRootNode();
contextNode.setUserData(XQuery10BpelFunctions.USER_DATA_KEY_FUNCTION_RESOLVER,
funcResolver, null);
exp.bindItem(XQConstants.CONTEXT_ITEM,
xqconn.createItemFromNode(contextNode, xqconn.createNodeType()));
// Execute query
XQResultSequence result = exp.executeQuery();
// Cast Saxon result to Java result
Object evalResult = getResultValue(type, result);
if ((evalResult != null) && __log.isDebugEnabled()) {
__log.debug("Expression " + cexp.toString() +
" generated result " + evalResult + " - type=" +
evalResult.getClass().getName());
if (ctx.getRootNode() != null) {
__log.debug("Was using context node " +
DOMUtils.domToString(ctx.getRootNode()));
}
}
return evalResult;
} catch (XQException xqe) {
// Extracting the real cause from all this wrapping isn't a simple task
Throwable cause = (xqe.getCause() != null) ? xqe.getCause() : xqe;
/*
if (cause instanceof DynamicError) {
Throwable th = ((DynamicError) cause).getException();
if (th != null) {
cause = th;
if (cause.getCause() != null) {
cause = cause.getCause();
}
}
}
*/
throw new EvaluationException(
"Error while executing an XQuery expression: " + cause.toString(), cause);
} catch (WrappedResolverException wre) {
__log.debug("Could not evaluate expression because of ", wre);
throw (FaultException) wre.getCause();
}
}
/**
* Return opaque object embedded in XQuery Item
*
* @param item item
*
* @return type
*
* @throws XQException XQException
*/
private Object getItemValue(XQItem item) throws XQException {
XQItemType itemType = item.getItemType();
Object itemValue = null;
switch (itemType.getBaseType()) {
case XQItemType.XQBASETYPE_BOOLEAN:
itemValue = item.getBoolean();
break;
case XQItemType.XQBASETYPE_DECIMAL:
itemValue = item.getDouble();
break;
case XQItemType.XQBASETYPE_BYTE:
itemValue = item.getByte();
break;
case XQItemType.XQBASETYPE_FLOAT:
itemValue = item.getFloat();
break;
case XQItemType.XQBASETYPE_INT:
case XQItemType.XQBASETYPE_INTEGER:
itemValue = item.getInt();
break;
case XQItemType.XQBASETYPE_LONG:
itemValue = item.getLong();
break;
case XQItemType.XQBASETYPE_ANYTYPE:
itemValue = item.getNode();
break;
case XQItemType.XQBASETYPE_ANYURI:
itemValue = item.getNodeUri();
break;
case XQItemType.XQBASETYPE_SHORT:
itemValue = item.getShort();
break;
case XQItemType.XQBASETYPE_STRING:
case XQItemType.XQBASETYPE_ANYATOMICTYPE:
itemValue = item.getAtomicValue();
break;
}
return itemValue;
}
/**
* Return XQuery type corresponding to given value
*
* @param xqconn XQuery connection
* @param value value
*
* @return type
*
* @throws XQException XQException
*/
private XQSequenceType getItemType(XQConnection xqconn, Object value) throws XQException {
XQSequenceType xqType = null;
if (value instanceof Long) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_LONG);
} else if (value instanceof String) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_STRING);
} else if (value instanceof Boolean) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_BOOLEAN);
} else if (value instanceof Date) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_DATETIME);
} else if (value instanceof BigDecimal) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_DECIMAL);
} else if (value instanceof Float) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_FLOAT);
} else if (value instanceof URI) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_ANYURI);
} else if (value instanceof QName) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_QNAME);
} else if (value instanceof BigInteger) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_INT);
} else if (value instanceof Integer) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_INTEGER);
} else if (value instanceof Double) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_DOUBLE);
} else if (value instanceof Byte) {
xqType = xqconn.createAtomicType(XQItemType.XQBASETYPE_BYTE);
} else if (value instanceof Node) {
xqType = xqconn.createNodeType();
} else if (value instanceof NodeList || value instanceof XQSequence) {
XQItemType xqItemType = xqconn.createNodeType();
xqType = xqconn.createSequenceType(xqItemType, XQSequenceType.OCC_ZERO_OR_MORE);
}
return xqType;
}
/**
* Cast XQuery sequence into an opaque list
*
* @param type type
* @param result result
*
* @return value
*
* @throws XQException XQException
*/
private Object getResultValue(QName type, XQResultSequence result) throws XQException {
Document document = DOMUtils.newDocument();
Object resultValue = null;
if (XPathConstants.NODESET.equals(type)) {
List list = new ArrayList();
while (result.next()) {
Object itemValue = getItemValue(result.getItem());
if (itemValue instanceof Document) {
itemValue = DOMUtils.cloneNode(document, ((Document) itemValue).getDocumentElement());
} else if (itemValue instanceof Node) {
itemValue = DOMUtils.cloneNode(document, (Node) itemValue);
}
if (itemValue != null) {
list.add(itemValue);
}
}
resultValue = list;
} else if (XPathConstants.NODE.equals(type)) {
XQItem item = null;
if (result.count() > 0) {
result.first();
if (result.isOnItem()) {
item = result.getItem();
}
}
if (item != null) {
resultValue = getItemValue(item);
if (resultValue instanceof Node) {
resultValue = DOMUtils.cloneNode(document, (Node) resultValue);
}
}
} else if (XPathConstants.STRING.equals(type)) {
resultValue = result.getSequenceAsString(new Properties());
} else if (XPathConstants.NUMBER.equals(type)) {
resultValue = result.getSequenceAsString(new Properties());
resultValue = Integer.parseInt((String) resultValue);
} else if (XPathConstants.BOOLEAN.equals(type)) {
resultValue = result.getSequenceAsString(new Properties());
resultValue = Boolean.parseBoolean((String) resultValue);
}
return resultValue;
}
}