/**
* Map a Jena graph node to a Mulgara value.
*
* @param x The Jena Node to convert.
* @param session A session to use for blank node persistence.
* @return A Mulgara Value.
* @throws URISyntaxException When creating a URIReference that refers to an invalid URI.
*/
static Value n2v(Node x, Session session) throws URISyntaxException {
if (x.isURI()) return new URIReferenceImpl(new URI(x.getURI()));
if (x.isLiteral()) {
// The return types are Mulgara LiteralImpl
if (x.getLiteralDatatypeURI() != null) {
return new LiteralImpl(x.getLiteralLexicalForm(), new URI(x.getLiteralDatatypeURI()));
}
if (x.getLiteralLanguage() != null) {
return new LiteralImpl(x.getLiteralLexicalForm(), x.getLiteralLanguage());
}
return new LiteralImpl(x.getLiteralLexicalForm());
}
if (x.isBlank()) {
// is this a previously encountered Jena-allocated node?
Value bn = nodesToValues.get(x);
if (bn != null) return bn;
// May be a Mulgara-allocated bNode (and so we we have seen before)
String blankLabel = x.getBlankNodeLabel();
if (blankLabel.startsWith(LABEL)) {
long id = Long.parseLong(blankLabel.substring(LABEL_LEN));
return new BlankNodeImpl(BlankNodeImpl.counterToNode(id));
}
// It's not - it's a Jena one.
if (skolemizedBlankNodes) {
String skol = bNodeScheme + x.getBlankNodeLabel();
return new URIReferenceImpl(new URI(skol));
}
// Not a Mulgara-allocated bNode. Create a new mapping.
BlankNodeImpl v = new BlankNodeImpl();
nodesToValues.put(x, v);
valuesToNodes.put(v.getNodeId(), x);
return v;
}
throw new RuntimeException("Can't convert from Jena node : " + x);
}
protected static String sparqlNode(Node node, String varName) {
if (node == null || node.isVariable()) {
return varName;
} else if (node.isBlank()) {
return "<fake:blank>"; // or throw exception?
} else if (node.isURI()) {
StringBuffer uriBuff = new StringBuffer();
return uriBuff.append("<").append(node.getURI()).append(">").toString();
} else if (node.isLiteral()) {
StringBuffer literalBuff = new StringBuffer();
literalBuff.append("\"");
pyString(literalBuff, node.getLiteralLexicalForm());
literalBuff.append("\"");
if (node.getLiteralDatatypeURI() != null) {
literalBuff.append("^^<").append(node.getLiteralDatatypeURI()).append(">");
} else if (node.getLiteralLanguage() != null && node.getLiteralLanguage().length() > 0) {
literalBuff.append("@").append(node.getLiteralLanguage());
}
return literalBuff.toString();
} else {
return varName;
}
}
public static Node datatype(Node node) {
if (!node.isLiteral()) {
NodeValue.raise(new ExprTypeException("datatype: Not a literal: " + node));
return null;
}
String s = node.getLiteralDatatypeURI();
boolean plainLiteral = (s == null || s.equals(""));
if (plainLiteral) {
boolean simpleLiteral =
(node.getLiteralLanguage() == null || node.getLiteralLanguage().equals(""));
if (!simpleLiteral)
NodeValue.raise(new ExprTypeException("datatype: Literal has language tag: " + node));
return XSD.xstring.asNode();
}
return Node.createURI(s);
}
/**
* Gets NXRelations node instance given Jena node.
*
* @param jenaNodeInst
* @return NXRelations node instance
*/
private Node getNXRelationsNode(com.hp.hpl.jena.graph.Node jenaNodeInst) {
if (jenaNodeInst == null) {
return null;
}
Node nuxNode = null;
if (jenaNodeInst.isBlank()) {
AnonId anonId = jenaNodeInst.getBlankNodeId();
String id = anonId.getLabelString();
nuxNode = NodeFactory.createBlank(id);
} else if (jenaNodeInst.isLiteral()) {
LiteralLabel label = jenaNodeInst.getLiteral();
String value = label.getLexicalForm();
String type = jenaNodeInst.getLiteralDatatypeURI();
String language = jenaNodeInst.getLiteralLanguage();
if (type != "") {
nuxNode = NodeFactory.createTypedLiteral(value, type);
} else if (language != "") {
nuxNode = NodeFactory.createLiteral(value, language);
} else {
nuxNode = NodeFactory.createLiteral(value);
}
} else if (jenaNodeInst.isURI()) {
String uri = jenaNodeInst.getURI();
// try to find corresponding prefix
// TODO AT: maybe take namespaces from relation service?
for (Map.Entry<String, String> ns : namespaces.entrySet()) {
String base = ns.getValue();
if (uri.startsWith(base)) {
String localName = uri.substring(base.length());
nuxNode = NodeFactory.createQNameResource(base, localName);
break;
}
}
if (nuxNode == null) {
// default to resource
nuxNode = NodeFactory.createResource(uri);
}
} else {
throw new IllegalArgumentException(
"Cannot translate non concrete Jena node into NXRelations node");
}
return nuxNode;
}
private void convertNotEquals(E_NotEquals expr) {
logger.debug("convertNotEquals " + expr.toString());
expr.getArg1().visit(this);
expr.getArg2().visit(this);
Expression e2 = expression.pop();
Expression e1 = expression.pop();
// TODO Expression.FALSE and Expression.TRUE are not constants
if (e1.equals(Expression.FALSE)) e1 = CONSTANT_FALSE;
else if (e1.equals(Expression.TRUE)) e1 = CONSTANT_TRUE;
if (e2.equals(Expression.FALSE)) e2 = CONSTANT_FALSE;
else if (e2.equals(Expression.TRUE)) e2 = CONSTANT_TRUE;
if (e1 instanceof AttributeExprEx && e2 instanceof Constant
|| e2 instanceof AttributeExprEx && e1 instanceof Constant) {
AttributeExprEx variable;
ConstantEx constant;
if (e1 instanceof AttributeExprEx) {
variable = (AttributeExprEx) e1;
constant = (ConstantEx) e2;
} else {
variable = (AttributeExprEx) e2;
constant = (ConstantEx) e1;
}
logger.debug("isNotEqual(" + variable + ", " + constant + ")");
NodeMaker nm = variable.getNodeMaker();
if (nm instanceof TypedNodeMaker) {
ValueMaker vm = ((TypedNodeMaker) nm).valueMaker();
Node node = constant.getNode();
logger.debug("checking " + node + " with " + nm);
if (XSD.isNumeric(node)) {
DetermineNodeType filter = new DetermineNodeType();
nm.describeSelf(filter);
RDFDatatype datatype = filter.getDatatype();
if (datatype != null && XSD.isNumeric(datatype)) {
RDFDatatype numericType = XSD.getNumericType(datatype, node.getLiteralDatatype());
nm = cast(nm, numericType);
node = XSD.cast(node, numericType);
}
}
boolean empty = nm.selectNode(node, RelationalOperators.DUMMY).equals(NodeMaker.EMPTY);
logger.debug("result " + new Boolean(empty));
if (!empty) {
if (node.isURI()) expression.push(new Negation(vm.valueExpression(node.getURI())));
else if (node.isLiteral()) {
if (XSD.isSupported(node.getLiteralDatatype()))
expression.push(new Negation(vm.valueExpression(constant.value())));
else // type = boolean or an unknown type
conversionFailed("cannot compare values of type " + node.getLiteralDatatypeURI(), expr);
} else conversionFailed(expr); // TODO blank nodes?
return;
} else {
expression.push(Expression.TRUE);
return;
}
}
} else if (e1 instanceof ConstantEx && e2 instanceof ConstantEx) {
logger.debug("isNotEqual(" + e1 + ", " + e2 + ")");
Node c1 = ((ConstantEx) e1).getNode();
Node c2 = ((ConstantEx) e2).getNode();
boolean equals;
if (XSD.isNumeric(c1) && XSD.isNumeric(c2)) {
RDFDatatype datatype = XSD.getNumericType(c1.getLiteralDatatype(), c2.getLiteralDatatype());
equals = XSD.cast(c1, datatype).equals(XSD.cast(c2, datatype));
} else if (isSimpleLiteral(c1) && isSimpleLiteral(c2)) {
equals = c1.getLiteralValue().equals(c2.getLiteralValue());
} else if (XSD.isString(c1) && XSD.isString(c2)) {
equals = c1.getLiteralValue().equals(c2.getLiteralValue());
} else {
try {
equals = NodeFunctions.rdfTermEquals(c1, c2);
} catch (ExprEvalException e) {
equals = false;
}
}
logger.debug("constants equal? " + new Boolean(equals));
expression.push(equals ? Expression.FALSE : Expression.TRUE);
return;
} else if (e1 instanceof AttributeExprEx && e2 instanceof AttributeExprEx) {
logger.debug("isNotEqual(" + e1 + ", " + e2 + ")");
AttributeExprEx variable1 = (AttributeExprEx) e1;
AttributeExprEx variable2 = (AttributeExprEx) e2;
NodeMaker nm1 = variable1.getNodeMaker();
NodeMaker nm2 = variable2.getNodeMaker();
DetermineNodeType filter1 = new DetermineNodeType();
nm1.describeSelf(filter1);
RDFDatatype datatype1 = filter1.getDatatype();
DetermineNodeType filter2 = new DetermineNodeType();
nm2.describeSelf(filter2);
RDFDatatype datatype2 = filter2.getDatatype();
if (datatype1 != null
&& XSD.isNumeric(datatype1)
&& datatype2 != null
&& XSD.isNumeric(datatype2)) {
RDFDatatype numericType = XSD.getNumericType(filter1.getDatatype(), filter2.getDatatype());
nm1 = cast(nm1, numericType);
nm2 = cast(nm2, numericType);
}
NodeSetConstraintBuilder nodeSet = new NodeSetConstraintBuilder();
nm1.describeSelf(nodeSet);
nm2.describeSelf(nodeSet);
if (nodeSet.isEmpty()) {
logger.debug("nodes " + nm1 + " " + nm2 + " incompatible");
expression.push(Expression.TRUE);
return;
}
}
expression.push(new Negation(Equality.create(e1, e2)));
}