[Mulgara-svn] r1602 - in trunk/src/jar/query/java/org/mulgara/query/filter: . arithmetic value
pag at mulgara.org
pag at mulgara.org
Thu Mar 12 06:48:31 UTC 2009
Author: pag
Date: 2009-03-11 23:48:30 -0700 (Wed, 11 Mar 2009)
New Revision: 1602
Added:
trunk/src/jar/query/java/org/mulgara/query/filter/InequalityComparisonUnitTest.java
Modified:
trunk/src/jar/query/java/org/mulgara/query/filter/AbstractFilterValue.java
trunk/src/jar/query/java/org/mulgara/query/filter/EqualityComparisonUnitTest.java
trunk/src/jar/query/java/org/mulgara/query/filter/Filter.java
trunk/src/jar/query/java/org/mulgara/query/filter/NotEquals.java
trunk/src/jar/query/java/org/mulgara/query/filter/RDFTerm.java
trunk/src/jar/query/java/org/mulgara/query/filter/arithmetic/AbstractNumericOperation.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/AbstractComparable.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/AbstractComparableLiteral.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/BlankNodeValue.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/BlankNodeValueUnitTest.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/IRI.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/NumericLiteral.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/NumericLiteralUnitTest.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/SimpleLiteral.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/TypedLiteral.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/Var.java
trunk/src/jar/query/java/org/mulgara/query/filter/value/VarUnitTest.java
Log:
Updated compare and equals tests to better conform with the SPARQL spec. This means NOT throwing type errors for most literal types, and doing numeric conversions for number literals. Added new Inequality test class to get better coverage of this
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/AbstractFilterValue.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/AbstractFilterValue.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/AbstractFilterValue.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -95,9 +95,6 @@
/** @see org.mulgara.query.filter.RDFTerm#isURI() */
public boolean isURI() throws QueryException { return isIRI(); }
- /** @see org.mulgara.query.filter.RDFTerm#notEquals(org.mulgara.query.filter.RDFTerm) */
- public boolean notEquals(RDFTerm v) throws QueryException { return !resolve().equals(v); }
-
/** @see org.mulgara.query.filter.RDFTerm#sameTerm(org.mulgara.query.filter.RDFTerm) */
public boolean sameTerm(RDFTerm v) throws QueryException { return resolve().sameTerm(v); }
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/EqualityComparisonUnitTest.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/EqualityComparisonUnitTest.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/EqualityComparisonUnitTest.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -88,36 +88,30 @@
// compare unequal literals
RDFTerm lhs = t;
RDFTerm rhs = f;
+ assertTrue(f.equals(new Equals(lhs, rhs)));
+ assertTrue(f.equals(new SameTerm(lhs, rhs)));
+ assertTrue(t.equals(new NotEquals(lhs, rhs)));
+
+ // compare incomparable literals
+ lhs = TypedLiteral.newLiteral(7);
try {
assertTrue(f.equals(new Equals(lhs, rhs)));
- fail("Unequal literals should throw an exception when compared for equality");
+ fail("Incomparable literals should throw an exception when compared for equality");
} catch (QueryException qe) {
assertTrue(qe.getMessage().startsWith("Type Error"));
}
- assertTrue(f.equals(new SameTerm(lhs, rhs)));
- assertTrue(t.equals(new NotEquals(lhs, rhs)));
// compare equivalent but different literals
lhs = TypedLiteral.newLiteral(7);
rhs = TypedLiteral.newLiteral(7.0);
- try {
- assertTrue(f.equals(new Equals(lhs, rhs)));
- fail("Unequal literals should throw an exception when compared for equality");
- } catch (QueryException qe) {
- assertTrue(qe.getMessage().startsWith("Type Error"));
- }
+ assertTrue(t.equals(new Equals(lhs, rhs)));
assertTrue(f.equals(new SameTerm(lhs, rhs)));
- assertTrue(t.equals(new NotEquals(lhs, rhs)));
+ assertTrue(f.equals(new NotEquals(lhs, rhs)));
// compare unequal literal strings
lhs = TypedLiteral.newLiteral("foo", null, null);
rhs = TypedLiteral.newLiteral("fool", null, null);
- try {
- assertTrue(f.equals(new Equals(lhs, rhs)));
- fail("Unequal literals should throw an exception when compared for equality");
- } catch (QueryException qe) {
- assertTrue(qe.getMessage().startsWith("Type Error"));
- }
+ assertTrue(f.equals(new Equals(lhs, rhs)));
assertTrue(f.equals(new SameTerm(lhs, rhs)));
assertTrue(t.equals(new NotEquals(lhs, rhs)));
@@ -131,17 +125,17 @@
assertTrue(qe.getMessage().startsWith("Type Error"));
}
assertTrue(f.equals(new SameTerm(lhs, rhs)));
- assertTrue(t.equals(new NotEquals(lhs, rhs)));
-
- // compare unequal languages
- lhs = TypedLiteral.newLiteral("foo", null, "en");
- rhs = TypedLiteral.newLiteral("foo", null, "fr");
try {
- assertTrue(f.equals(new Equals(lhs, rhs)));
+ assertTrue(t.equals(new NotEquals(lhs, rhs)));
fail("Unequal literals should throw an exception when compared for equality");
} catch (QueryException qe) {
assertTrue(qe.getMessage().startsWith("Type Error"));
}
+
+ // compare unequal languages
+ lhs = TypedLiteral.newLiteral("foo", null, "en");
+ rhs = TypedLiteral.newLiteral("foo", null, "fr");
+ assertTrue(f.equals(new Equals(lhs, rhs)));
assertTrue(f.equals(new SameTerm(lhs, rhs)));
assertTrue(t.equals(new NotEquals(lhs, rhs)));
@@ -203,6 +197,11 @@
new Node[] {simple, strEn},
new Node[] {simple, strFr},
+ new Node[] {seven, str},
+ new Node[] {sevenF, str},
+ new Node[] {str, seven},
+ new Node[] {str, sevenF},
+
new Node[] {str, str},
new Node[] {str, strEn},
new Node[] {strEn, strEn},
@@ -229,68 +228,70 @@
eq.setCurrentContext(c);
same.setCurrentContext(c);
ne.setCurrentContext(c);
-
- String results = "tl tlll tltl ff tff x tf";
+ // 01 2345 6789 0123 45 678 9 01
+ String results = "te tlff llll tltf ff tff x tf";
runTests(c, eq, same, ne, results);
}
private void runTests(TestContext c, AbstractFilterValue eq, AbstractFilterValue same, AbstractFilterValue ne, String results) throws Exception {
c.beforeFirst();
+ int i = 0;
for (char result: results.toCharArray()) {
if (result == ' ') continue;
+ String it = "iteration: " + i++;
assertTrue(c.next());
switch (result) {
case 't': // equal
- assertTrue(t.equals(eq));
- assertTrue(t.equals(same));
- assertTrue(f.equals(ne));
+ assertTrue(it, t.equals(eq));
+ assertTrue(it, t.equals(same));
+ assertTrue(it, f.equals(ne));
break;
case 'f': // unequal
- assertTrue(f.equals(eq));
- assertTrue(f.equals(same));
- assertTrue(t.equals(ne));
+ assertTrue(it, f.equals(eq));
+ assertTrue(it, f.equals(same));
+ assertTrue(it, t.equals(ne));
break;
case 'l': // unequal literals
- assertTrue(f.equals(same));
- assertTrue(t.equals(ne));
+ assertTrue(it, f.equals(same));
try {
- assertTrue(f.equals(eq));
- fail("Unequal literals should throw an exception when compared for equality");
+ assertTrue(it, t.equals(ne));
+ fail("Unequal literals should throw an exception when compared for equality: " + i);
} catch (QueryException qe) {
assertTrue(qe.getMessage().startsWith("Type Error"));
}
- break;
-
- case 'e': // equivalent but unequal
- assertTrue(t.equals(same));
- assertTrue(t.equals(ne));
try {
- assertTrue(f.equals(eq));
- fail("Unequal literals should throw an exception when compared for equality");
+ assertTrue(it, f.equals(eq));
+ fail("Unequal literals should throw an exception when compared for equality: " + i);
} catch (QueryException qe) {
assertTrue(qe.getMessage().startsWith("Type Error"));
}
break;
+ case 'e': // equivalent but unequal
+ assertTrue(it, f.equals(same));
+ assertTrue(it, f.equals(ne));
+ assertTrue(it, t.equals(eq));
+ break;
+
case 'x': // exception due to unbound
try {
- assertTrue(f.equals(eq));
- fail("No exception when testing an unbound value for equality");
+ assertTrue(it, f.equals(eq));
+ fail("No exception when testing an unbound value for equality: " + i);
} catch (QueryException qe) {
assertTrue(qe.getMessage().startsWith("Resolving unbound variable"));
}
try {
- assertTrue(f.equals(same));
- fail("No exception when testing an unbound value for equivalency");
+ assertTrue(it, f.equals(same));
+ fail("No exception when testing an unbound value for equivalency: " + i);
} catch (QueryException qe) {
assertTrue(qe.getMessage().startsWith("Resolving unbound variable"));
}
try {
- assertTrue(f.equals(ne));
- fail("No exception when testing an unbound value for inequality");
+ assertTrue(it, f.equals(ne));
+ fail("No exception when testing an unbound value for inequality: " + i);
} catch (QueryException qe) {
assertTrue(qe.getMessage().startsWith("Resolving unbound variable"));
}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/Filter.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/Filter.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/Filter.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -46,7 +46,6 @@
public boolean isIRI() throws QueryException { return false; }
public boolean isLiteral() throws QueryException { return true; }
public boolean isURI() throws QueryException { return false; }
- public boolean notEquals(RDFTerm v) throws QueryException { return !equals(v); }
public boolean sameTerm(RDFTerm v) throws QueryException { return equals(v); }
public void setContextOwner(ContextOwner owner) { }
};
Added: trunk/src/jar/query/java/org/mulgara/query/filter/InequalityComparisonUnitTest.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/InequalityComparisonUnitTest.java (rev 0)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/InequalityComparisonUnitTest.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -0,0 +1,382 @@
+/**
+ * The contents of this file are subject to the Open Software License
+ * Version 3.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.opensource.org/licenses/osl-3.0.txt
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ */
+package org.mulgara.query.filter;
+
+import java.net.URI;
+import java.util.Date;
+
+import org.jrdf.graph.Literal;
+import org.jrdf.graph.Node;
+import org.mulgara.query.QueryException;
+import org.mulgara.query.filter.TestContext;
+import org.mulgara.query.filter.TestContextOwner;
+import org.mulgara.query.rdf.LiteralImpl;
+
+import org.mulgara.query.filter.value.Bool;
+import org.mulgara.query.filter.value.ComparableExpression;
+import org.mulgara.query.filter.value.DateTime;
+import org.mulgara.query.filter.value.TypedLiteral;
+import org.mulgara.query.filter.value.Var;
+
+import static org.mulgara.query.rdf.XSD.*;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+
+/**
+ * Tests the < and > functions.
+ *
+ * @created Apr 15, 2008
+ * @author Paul Gearon
+ * @copyright © 2008 <a href="http://www.topazproject.org/">The Topaz Project</a>
+ * @licence <a href="{@docRoot}/../../LICENCE.txt">Open Software License v3.0</a>
+ */
+public class InequalityComparisonUnitTest extends TestCase {
+
+ protected URI xsdInt = INT_URI;
+ protected URI xsdFloat = FLOAT_URI;
+ protected URI xsdString = STRING_URI;
+ Bool t = Bool.TRUE;
+ Bool f = Bool.FALSE;
+
+ /**
+ * Build the unit test.
+ * @param name The name of the test
+ */
+ public InequalityComparisonUnitTest(String name) {
+ super(name);
+ }
+
+ /**
+ * Hook for test runner to obtain a test suite from.
+ * @return The test suite
+ */
+ public static Test suite() {
+ TestSuite suite = new TestSuite();
+ suite.addTest(new InequalityComparisonUnitTest("testLT"));
+ suite.addTest(new InequalityComparisonUnitTest("testLTE"));
+ suite.addTest(new InequalityComparisonUnitTest("testGT"));
+ suite.addTest(new InequalityComparisonUnitTest("testGTE"));
+ suite.addTest(new InequalityComparisonUnitTest("testVar"));
+ return suite;
+ }
+
+ private void fnTst(BinaryComparisonFilter fn, Bool expected) throws QueryException {
+ assertTrue(expected.equals(fn));
+ assertTrue(fn.equals(expected));
+ }
+
+
+ public void testLT() throws Exception {
+ // compares two equal literals
+ fnTst(new LessThan(t, t), f);
+ fnTst(new LessThan(f, f), f);
+ fnTst(new LessThan(f, t), t);
+ fnTst(new LessThan(t, f), f);
+
+ ComparableExpression lhs = TypedLiteral.newLiteral(7);
+ ComparableExpression rhs = TypedLiteral.newLiteral(7.0);
+ fnTst(new LessThan(lhs, lhs), f);
+ fnTst(new LessThan(lhs, rhs), f);
+ fnTst(new LessThan(rhs, lhs), f);
+
+ rhs = TypedLiteral.newLiteral(8.0);
+ fnTst(new LessThan(lhs, rhs), t);
+ fnTst(new LessThan(rhs, lhs), f);
+
+ // compare unequal literal strings
+ lhs = TypedLiteral.newLiteral("foo", null, null);
+ rhs = TypedLiteral.newLiteral("fool", null, null);
+ fnTst(new LessThan(lhs, rhs), t);
+ fnTst(new LessThan(rhs, lhs), f);
+
+ // compare unequal literals types
+ rhs = TypedLiteral.newLiteral("foo", xsdString, null);
+ try {
+ assertTrue(f.equals(new LessThan(lhs, rhs)));
+ fail("Unequal literals should throw an exception when compared for inequality");
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Type Error"));
+ }
+
+ Date date = new Date();
+ lhs = new DateTime(date);
+ rhs = new DateTime(new Date(date.getTime() + 1000));
+ fnTst(new LessThan(lhs, rhs), t);
+ fnTst(new LessThan(rhs, lhs), f);
+ }
+
+ public void testGT() throws Exception {
+ // compares two equal literals
+ fnTst(new GreaterThan(t, t), f);
+ fnTst(new GreaterThan(f, f), f);
+ fnTst(new GreaterThan(f, t), f);
+ fnTst(new GreaterThan(t, f), t);
+
+ ComparableExpression lhs = TypedLiteral.newLiteral(7);
+ ComparableExpression rhs = TypedLiteral.newLiteral(7.0);
+ fnTst(new GreaterThan(lhs, lhs), f);
+ fnTst(new GreaterThan(lhs, rhs), f);
+ fnTst(new GreaterThan(rhs, lhs), f);
+
+ rhs = TypedLiteral.newLiteral(8.0);
+ fnTst(new GreaterThan(lhs, rhs), f);
+ fnTst(new GreaterThan(rhs, lhs), t);
+
+ // compare unequal literal strings
+ lhs = TypedLiteral.newLiteral("foo", null, null);
+ rhs = TypedLiteral.newLiteral("foo", null, null);
+ fnTst(new GreaterThan(lhs, rhs), f);
+ fnTst(new GreaterThan(rhs, lhs), f);
+ rhs = TypedLiteral.newLiteral("fool", null, null);
+ fnTst(new GreaterThan(lhs, rhs), f);
+ fnTst(new GreaterThan(rhs, lhs), t);
+
+ // compare unequal literals types
+ rhs = TypedLiteral.newLiteral("foo", xsdString, null);
+ try {
+ assertTrue(f.equals(new GreaterThan(lhs, rhs)));
+ fail("Unequal literals should throw an exception when compared for inequality");
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Type Error"));
+ }
+
+ Date date = new Date();
+ lhs = new DateTime(date);
+ rhs = new DateTime(new Date(date.getTime() + 1000));
+ fnTst(new GreaterThan(lhs, rhs), f);
+ fnTst(new GreaterThan(rhs, lhs), t);
+ }
+
+ public void testLTE() throws Exception {
+ // compares two equal literals
+ fnTst(new LessThanEqualTo(t, t), t);
+ fnTst(new LessThanEqualTo(f, f), t);
+ fnTst(new LessThanEqualTo(f, t), t);
+ fnTst(new LessThanEqualTo(t, f), f);
+
+ ComparableExpression lhs = TypedLiteral.newLiteral(7);
+ ComparableExpression rhs = TypedLiteral.newLiteral(7.0);
+ fnTst(new LessThanEqualTo(lhs, lhs), t);
+ fnTst(new LessThanEqualTo(lhs, rhs), t);
+ fnTst(new LessThanEqualTo(rhs, lhs), t);
+
+ rhs = TypedLiteral.newLiteral(8.0);
+ fnTst(new LessThanEqualTo(lhs, rhs), t);
+ fnTst(new LessThanEqualTo(rhs, lhs), f);
+
+ // compare unequal literal strings
+ lhs = TypedLiteral.newLiteral("foo", null, null);
+ rhs = TypedLiteral.newLiteral("foo", null, null);
+ fnTst(new LessThanEqualTo(lhs, rhs), t);
+ fnTst(new LessThanEqualTo(rhs, lhs), t);
+ rhs = TypedLiteral.newLiteral("fool", null, null);
+ fnTst(new LessThanEqualTo(lhs, rhs), t);
+ fnTst(new LessThanEqualTo(rhs, lhs), f);
+
+ // compare unequal literals types
+ rhs = TypedLiteral.newLiteral("foo", xsdString, null);
+ try {
+ assertTrue(f.equals(new LessThanEqualTo(lhs, rhs)));
+ fail("Unequal literals should throw an exception when compared for inequality");
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Type Error"));
+ }
+
+ Date date = new Date();
+ lhs = new DateTime(date);
+ rhs = new DateTime(new Date(date.getTime() + 1000));
+ fnTst(new LessThanEqualTo(lhs, rhs), t);
+ fnTst(new LessThanEqualTo(rhs, lhs), f);
+ }
+
+ public void testGTE() throws Exception {
+ // compares two equal literals
+ fnTst(new GreaterThanEqualTo(t, t), t);
+ fnTst(new GreaterThanEqualTo(f, f), t);
+ fnTst(new GreaterThanEqualTo(f, t), f);
+ fnTst(new GreaterThanEqualTo(t, f), t);
+
+ ComparableExpression lhs = TypedLiteral.newLiteral(7);
+ ComparableExpression rhs = TypedLiteral.newLiteral(7.0);
+ fnTst(new GreaterThanEqualTo(lhs, lhs), t);
+ fnTst(new GreaterThanEqualTo(lhs, rhs), t);
+ fnTst(new GreaterThanEqualTo(rhs, lhs), t);
+
+ rhs = TypedLiteral.newLiteral(8.0);
+ fnTst(new GreaterThanEqualTo(lhs, rhs), f);
+ fnTst(new GreaterThanEqualTo(rhs, lhs), t);
+
+ // compare unequal literal strings
+ lhs = TypedLiteral.newLiteral("foo", null, null);
+ rhs = TypedLiteral.newLiteral("foo", null, null);
+ fnTst(new GreaterThanEqualTo(lhs, rhs), t);
+ fnTst(new GreaterThanEqualTo(rhs, lhs), t);
+ rhs = TypedLiteral.newLiteral("fool", null, null);
+ fnTst(new GreaterThan(lhs, rhs), f);
+ fnTst(new GreaterThan(rhs, lhs), t);
+
+ // compare unequal literals types
+ rhs = TypedLiteral.newLiteral("foo", xsdString, null);
+ try {
+ assertTrue(f.equals(new GreaterThanEqualTo(lhs, rhs)));
+ fail("Unequal literals should throw an exception when compared for inequality");
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Type Error"));
+ }
+
+ Date date = new Date();
+ lhs = new DateTime(date);
+ rhs = new DateTime(new Date(date.getTime() + 1000));
+ fnTst(new GreaterThanEqualTo(lhs, rhs), f);
+ fnTst(new GreaterThanEqualTo(rhs, lhs), t);
+ }
+
+ public void testVar() throws Exception {
+ Var x = new Var("x");
+ Var y = new Var("y");
+ AbstractFilterValue lt = new LessThan(x, y);
+ AbstractFilterValue lte = new LessThanEqualTo(x, y);
+ AbstractFilterValue gt = new GreaterThan(x, y);
+ AbstractFilterValue gte = new GreaterThanEqualTo(x, y);
+
+ Literal seven = new LiteralImpl("7", xsdInt);
+ Literal sevenF = new LiteralImpl("7.0", xsdFloat);
+ Literal eight = new LiteralImpl("8", xsdInt);
+ Literal eightF = new LiteralImpl("8.0", xsdFloat);
+ Literal simple = new LiteralImpl("foo");
+ Literal simpleLarge = new LiteralImpl("goo");
+ Literal str = new LiteralImpl("foo", xsdString);
+ Literal strLarge = new LiteralImpl("goo", xsdString);
+ Node[][] rows = {
+ new Node[] {seven, seven},
+ new Node[] {seven, sevenF},
+ new Node[] {seven, eight},
+ new Node[] {seven, eightF},
+
+ new Node[] {simple, simple},
+ new Node[] {simple, simpleLarge},
+ new Node[] {simple, str},
+
+ new Node[] {seven, str},
+ new Node[] {sevenF, str},
+ new Node[] {str, seven},
+ new Node[] {str, sevenF},
+
+ new Node[] {str, str},
+ new Node[] {str, strLarge},
+
+ new Node[] {null, str},
+ };
+ TestContext c = new TestContext(new String[] {"x", "y"}, rows);
+ c.beforeFirst();
+ lt.setContextOwner(new TestContextOwner(c));
+ lte.setContextOwner(new TestContextOwner(c));
+ gt.setContextOwner(new TestContextOwner(c));
+ gte.setContextOwner(new TestContextOwner(c));
+ // check the context setting
+ lt.setCurrentContext(c);
+ lte.setCurrentContext(c);
+ gt.setCurrentContext(c);
+ gte.setCurrentContext(c);
+ // 0123 456 7890 12 3
+ String results = "eell elx xxxx el n";
+ runTests(c, lt, lte, gt, gte, results);
+
+ }
+
+ private void runTests(TestContext c, AbstractFilterValue lt, AbstractFilterValue lte, AbstractFilterValue gt, AbstractFilterValue gte, String results) throws Exception {
+ c.beforeFirst();
+ int i = 0;
+ for (char result: results.toCharArray()) {
+ if (result == ' ') continue;
+ String it = "iteration: " + i++;
+ assertTrue(c.next());
+ switch (result) {
+ case 'e': // equal
+ assertTrue(it, f.equals(lt));
+ assertTrue(it, t.equals(lte));
+ assertTrue(it, f.equals(gt));
+ assertTrue(it, t.equals(gte));
+ break;
+
+ case 'l': // less than
+ assertTrue(it, t.equals(lt));
+ assertTrue(it, t.equals(lte));
+ assertTrue(it, f.equals(gt));
+ assertTrue(it, f.equals(gte));
+ break;
+
+ case 'x': // Type error
+ try {
+ assertTrue(it, t.equals(lt));
+ fail("Unequal literals should throw an exception when compared for less than: " + i);
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Type Error"));
+ }
+ try {
+ assertTrue(it, t.equals(lte));
+ fail("Unequal literals should throw an exception when compared for less than or equal: " + i);
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Type Error"));
+ }
+ try {
+ assertTrue(it, t.equals(gt));
+ fail("Unequal literals should throw an exception when compared for greater than: " + i);
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Type Error"));
+ }
+ try {
+ assertTrue(it, t.equals(gte));
+ fail("Unequal literals should throw an exception when compared for greater than or equal: " + i);
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Type Error"));
+ }
+ break;
+
+ case 'n': // exception due to unbound
+ try {
+ assertTrue(it, f.equals(lt));
+ fail("No exception when testing an unbound value for equality: " + i);
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Resolving unbound variable"));
+ }
+ try {
+ assertTrue(it, f.equals(lte));
+ fail("No exception when testing an unbound value for equivalency: " + i);
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Resolving unbound variable"));
+ }
+ try {
+ assertTrue(it, f.equals(gt));
+ fail("No exception when testing an unbound value for inequality: " + i);
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Resolving unbound variable"));
+ }
+ try {
+ assertTrue(it, f.equals(gte));
+ fail("No exception when testing an unbound value for inequality: " + i);
+ } catch (QueryException qe) {
+ assertTrue(qe.getMessage().startsWith("Resolving unbound variable"));
+ }
+ break;
+
+ default:
+ fail("Bad test data");
+ }
+ }
+ assertFalse(c.next());
+ }
+
+}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/NotEquals.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/NotEquals.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/NotEquals.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -33,7 +33,7 @@
/** @see org.mulgara.query.filter.BinaryTestFilter#testCmp() */
boolean testCmp() throws QueryException {
- return lhs.notEquals(rhs);
+ return !lhs.equals(rhs);
}
}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/RDFTerm.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/RDFTerm.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/RDFTerm.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -43,15 +43,6 @@
public boolean equals(RDFTerm v) throws QueryException;
/**
- * A value based inequality test.
- * @param v The object to compare to
- * @return <code>false</code> iff v has the same value as the current object.
- * @throws QueryException Resolving the data for this value leads to an error,
- * or the types are incompatible.
- */
- public boolean notEquals(RDFTerm v) throws QueryException;
-
- /**
* Tests if this object is a URI or IRI.
* @return <code>true</code> if this object is an IRI.
*/
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/arithmetic/AbstractNumericOperation.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/arithmetic/AbstractNumericOperation.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/arithmetic/AbstractNumericOperation.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -51,9 +51,6 @@
/** @see org.mulgara.query.filter.RDFTerm#isURI() */
public boolean isURI() throws QueryException { return false; }
- /** @see org.mulgara.query.filter.RDFTerm#notEquals() */
- public boolean notEquals(RDFTerm v) throws QueryException { return compare(getNumber(), v.getValue()) != 0; }
-
/** @see org.mulgara.query.filter.RDFTerm#sameTerm() */
public boolean sameTerm(RDFTerm v) throws QueryException { return getNumber().equals(v.getValue()); }
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/AbstractComparable.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/AbstractComparable.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/AbstractComparable.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -57,11 +57,6 @@
return compare(getValue(), v.getValue()) == 0;
}
- /** {@inheritDoc} */
- public boolean notEquals(ComparableExpression v) throws QueryException {
- return !equals(v);
- }
-
/**
* Tests a value to see if it is a simple literal, and throws an exception if it is.
* Simple literals do a similar test when compared with a ComparableExpression.
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/AbstractComparableLiteral.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/AbstractComparableLiteral.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/AbstractComparableLiteral.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -11,12 +11,15 @@
*/
package org.mulgara.query.filter.value;
+import java.math.BigDecimal;
+import java.net.URI;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.mulgara.query.QueryException;
import org.mulgara.query.filter.RDFTerm;
+import org.mulgara.query.rdf.XSD;
/**
@@ -74,7 +77,7 @@
/** {@inheritDoc} */
public boolean sameTerm(RDFTerm v) throws QueryException {
if (!v.isLiteral()) return false;
- return equalLiteralTypes((ValueLiteral)v) && getValue().equals(v.getValue());
+ return comparableLiteralTypes((ValueLiteral)v) && getValue().equals(v.getValue());
}
/**
@@ -86,24 +89,48 @@
*/
public boolean equals(RDFTerm v) throws QueryException {
if (!v.isLiteral()) return false;
- // compare types, and then check values
- if (equalLiteralTypes((ValueLiteral)v) && getValue().equals(v.getValue())) return true;
+ // numbers are compared differently
+ if (isNumber(v) && isNumber(this)) return numericEquals(v);
+
+ // simple strings can do the comparison for us. This object cannot be simple,
+ // otherwise this method would not have been called.
+ if (((ValueLiteral)v).isSimple()) return v.equals(this);
+
+ // if the types allow for direct comparisons, then do so
+ if (directlyComparableTypes(v)) return getValue().equals(v.getValue());
+
+ // This is now RDFterm-equal, return true or an error
+ // compare for type equality, then value equality
+ if (comparableLiteralTypes(v) && getValue().equals(v.getValue())) return true;
throw new QueryException("Type Error: Terms are not equal");
}
-
+
+
/**
- * {@inheritDoc}
- * Not the inverse of #equals(). This method returns true when the elements connot be determined
- * to be equal.
+ * Indicates that an direct compare operation is valid on these types. This is defined
+ * to be valid for:
+ * <ul>
+ * <li>booleans</li>
+ * <li>dateTimes</li>
+ * <li>XSD strings</li>
+ * </ul>
+ * Simple strings and numbers are handled elsewhere.
+ * @param vl The other value literal to be compared against.
+ * @return <code>true</code> if direct comparison is allowed between these types.
+ * @throws QueryException If there is a data error accessing the types.
*/
- public boolean notEquals(RDFTerm v) throws QueryException {
- try {
- return !equals(v);
- } catch (QueryException qe) {
- return true;
- }
+ private boolean directlyComparableTypes(RDFTerm term) throws QueryException {
+ ValueLiteral vl = (ValueLiteral)term;
+ IRI otherType = vl.getType();
+ IRI thisType = getType();
+ assert otherType != null && thisType != null;
+ // if differing types, then can't be compared
+ if (!thisType.equals(otherType)) return false;
+ URI tt = thisType.getValue();
+ return tt.equals(XSD.BOOLEAN_URI) || tt.equals(XSD.DATE_TIME_URI) || thisType.equals(SimpleLiteral.STRING_TYPE);
}
+
/**
* Compares the type of this object to the type of another object. This takes into account
* that Simple Literals claim to have a string type, when they have no type at all.
@@ -112,28 +139,26 @@
* then both objects have to be typed literals, or untyped literals.
* @throws QueryException If there is an error accessing the type data.
*/
- private boolean equalLiteralTypes(ValueLiteral vl) throws QueryException {
+ private boolean comparableLiteralTypes(RDFTerm term) throws QueryException {
+ ValueLiteral vl = (ValueLiteral)term;
IRI opType = vl.getType();
IRI thisType = getType();
assert opType != null && thisType != null;
- // if the types differ, then not equal
- if (!opType.equals(thisType)) return false;
- // types are the same. If they are not strings, then definitely equal
- if (!opType.equals(SimpleLiteral.STRING_TYPE)) return true;
- // both types are strings. Only true if the other object is not a simple literal
- return !vl.isSimple();
+ // if the types differ, then the literals are definitely not equal
+ return opType.equals(thisType);
}
+
/**
* Extended numerical comparison function. Currently unused.
* @param v The term to compare against.
* @return <code>true</code> if this compares against v with semantic equivalence, regardless of lexical equivalence
* @throws QueryException Thrown when a value cannot be resolved, or if the types are no numbers.
*/
- @SuppressWarnings("unused")
- private boolean numberCompare(RDFTerm v) throws QueryException {
- if (!(value instanceof Number) || !(v.getValue() instanceof Number)) throw new QueryException("Terms are not equal");
- return compare(value, v) == 0;
+ private boolean numericEquals(RDFTerm v) throws QueryException {
+ Object ov = v.getValue();
+ if (!(value instanceof Number) || !(ov instanceof Number)) throw new QueryException("Terms are not equal");
+ return compare(value, ov) == 0;
}
/**
@@ -149,6 +174,18 @@
return cmpFn.compare(left, right);
}
+
+ /**
+ * Utility to test a literal to see if it is a numeric type. Accepts an RDFTerm for convenience.
+ * @param t A ValueLiteral to test to see if it is a number.
+ * @return <code>true</code> if the term is a number.
+ * @throws QueryException If there was an error accessing the value of the term.
+ */
+ private static final boolean isNumber(RDFTerm t) throws QueryException {
+ return NumericLiteral.isNumeric(((ValueLiteral)t).getType().getValue());
+ }
+
+
/** Map of class types to the functions used to compare those types */
protected static Map<Class<? extends Comparable<?>>,DataCompare> typeMap = new HashMap<Class<? extends Comparable<?>>,DataCompare>();
@@ -158,10 +195,11 @@
typeMap.put(Boolean.class, new BooleanCompare());
typeMap.put(Float.class, new FloatCompare());
typeMap.put(Double.class, new DoubleCompare());
- typeMap.put(Long.class, new DecimalCompare());
- typeMap.put(Integer.class, new DecimalCompare());
- typeMap.put(Short.class, new DecimalCompare());
- typeMap.put(Byte.class, new DecimalCompare());
+ typeMap.put(Long.class, new IntegralCompare());
+ typeMap.put(Integer.class, new IntegralCompare());
+ typeMap.put(Short.class, new IntegralCompare());
+ typeMap.put(Byte.class, new IntegralCompare());
+ typeMap.put(BigDecimal.class, new BigDecimalCompare());
}
/** Defines a function for comparing objects of arbitrary type */
@@ -231,7 +269,7 @@
}
/** Implements integer comparisons */
- private static class DecimalCompare implements DataCompare {
+ private static class IntegralCompare implements DataCompare {
public int compare(Object left, Object right) throws QueryException {
if (!(right instanceof Number)) throw new QueryException("Type Error: Cannot compare a decimal number to a: " + right.getClass());
Long lleft = ((Number)left).longValue();
@@ -240,4 +278,18 @@
public ValueLiteral newLiteral(Object data) { return new NumericLiteral((Number)data); }
}
+ /** Implements big-decimal comparisons */
+ private static class BigDecimalCompare implements DataCompare {
+ public int compare(Object left, Object right) throws QueryException {
+ if (!(right instanceof Number)) throw new QueryException("Type Error: Cannot compare a decimal number to a: " + right.getClass());
+ BigDecimal bleft = (BigDecimal)left;
+ if (right instanceof BigDecimal) return bleft.compareTo((BigDecimal)right);
+ if (right instanceof Double || right instanceof Float) {
+ return bleft.compareTo(BigDecimal.valueOf(((Number)right).doubleValue()));
+ }
+ return bleft.compareTo(BigDecimal.valueOf(((Number)right).longValue()));
+ }
+ public ValueLiteral newLiteral(Object data) { return new NumericLiteral((Number)data); }
+ }
+
}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/BlankNodeValue.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/BlankNodeValue.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/BlankNodeValue.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -52,11 +52,6 @@
}
/** {@inheritDoc} */
- public boolean notEquals(RDFTerm v) throws QueryException {
- return !equals(v);
- }
-
- /** {@inheritDoc} */
public boolean sameTerm(RDFTerm v) throws QueryException {
return equals(v);
}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/BlankNodeValueUnitTest.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/BlankNodeValueUnitTest.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/BlankNodeValueUnitTest.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -59,8 +59,6 @@
assertFalse(b2.equals(bv.getValue()));
BlankNodeValue bv2 = new BlankNodeValue(b2);
assertTrue(bv.equals(bv));
- assertTrue(bv.notEquals(bv2));
- assertFalse(bv.notEquals(bv));
assertFalse(bv.equals(bv2));
}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/IRI.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/IRI.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/IRI.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -63,11 +63,6 @@
}
/** {@inheritDoc} */
- public boolean notEquals(RDFTerm v) throws QueryException {
- return !equals(v);
- }
-
- /** {@inheritDoc} */
public boolean isBlank() { return false; }
/** {@inheritDoc} */
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/NumericLiteral.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/NumericLiteral.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/NumericLiteral.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -11,6 +11,7 @@
*/
package org.mulgara.query.filter.value;
+import java.math.BigDecimal;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
@@ -36,7 +37,7 @@
* @param n The number to wrap
*/
public NumericLiteral(Number n) {
- super(n, typeMap.get(n.getClass()));
+ super(n, numericTypeMap.get(n.getClass()));
}
/**
@@ -59,7 +60,7 @@
* @return An IRI containing the XSD datatype of n.
*/
public static IRI getTypeFor(Number n) {
- return new IRI(typeMap.get(n.getClass()));
+ return new IRI(numericTypeMap.get(n.getClass()));
}
/**
@@ -82,15 +83,16 @@
}
/** A mapping of numeric types to their URIs */
- private static final Map<Class<? extends Number>,URI> typeMap = new HashMap<Class<? extends Number>,URI>();
+ private static final Map<Class<? extends Number>,URI> numericTypeMap = new HashMap<Class<? extends Number>,URI>();
static {
- typeMap.put(Float.class, XSD.FLOAT_URI);
- typeMap.put(Double.class, XSD.DOUBLE_URI);
- typeMap.put(Long.class, XSD.LONG_URI);
- typeMap.put(Integer.class, XSD.INT_URI);
- typeMap.put(Short.class, XSD.SHORT_URI);
- typeMap.put(Byte.class, XSD.BYTE_URI);
+ numericTypeMap.put(Float.class, XSD.FLOAT_URI);
+ numericTypeMap.put(Double.class, XSD.DOUBLE_URI);
+ numericTypeMap.put(Long.class, XSD.LONG_URI);
+ numericTypeMap.put(Integer.class, XSD.INT_URI);
+ numericTypeMap.put(Short.class, XSD.SHORT_URI);
+ numericTypeMap.put(Byte.class, XSD.BYTE_URI);
+ numericTypeMap.put(BigDecimal.class, XSD.DECIMAL_URI);
}
}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/NumericLiteralUnitTest.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/NumericLiteralUnitTest.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/NumericLiteralUnitTest.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -11,6 +11,8 @@
*/
package org.mulgara.query.filter.value;
+import java.math.BigDecimal;
+
import org.mulgara.query.filter.Context;
import org.mulgara.query.filter.TestContext;
import static org.mulgara.query.rdf.XSD.*;
@@ -62,6 +64,11 @@
n = new NumericLiteral(six);
assertEquals(n.getValue(), six);
assertFalse(Double.valueOf(4).equals(n.getValue()));
+
+ BigDecimal large = new BigDecimal("12345678901234567890");
+ n = new NumericLiteral(large);
+ assertEquals(n.getValue(), large);
+ assertFalse(BigDecimal.valueOf(1234567890123456789L).equals(n.getValue()));
}
public void testFilter() throws Exception {
@@ -75,6 +82,11 @@
assertTrue(n.test(c));
n = new NumericLiteral(Double.valueOf(0));
assertFalse(n.test(c));
+
+ n = new NumericLiteral(BigDecimal.valueOf(5.0));
+ assertTrue(n.test(c));
+ n = new NumericLiteral(BigDecimal.ZERO);
+ assertFalse(n.test(c));
}
public void testType() throws Exception {
@@ -93,6 +105,10 @@
n = new NumericLiteral(Float.valueOf(5));
assertTrue(n.getType().isIRI());
assertEquals(n.getType().getValue(), FLOAT_URI);
+
+ n = new NumericLiteral(new BigDecimal("12345678901234567890"));
+ assertTrue(n.getType().isIRI());
+ assertEquals(n.getType().getValue(), DECIMAL_URI);
}
@@ -116,6 +132,12 @@
n2 = TypedLiteral.newLiteral(six);
assertTrue(n.equals(n2));
assertTrue(n.getType().equals(n2.getType()));
+
+ BigDecimal large = new BigDecimal("12345678901234567890");
+ n = new NumericLiteral(large);
+ n2 = TypedLiteral.newLiteral(large);
+ assertTrue(n.equals(n2));
+ assertTrue(n.getType().equals(n2.getType()));
}
}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/SimpleLiteral.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/SimpleLiteral.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/SimpleLiteral.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -105,8 +105,9 @@
/**
* {@inheritDoc}
- * This method will only return <code>true</code> when the elements are identical.
- * Since this object is a literal, then an incorrect comparison will throw an exception.
+ * This method will only return <code>true</code> when the elements are identical, and
+ * <code>false</code> when they are the same type, but different values.
+ * Since this object is a literal, then a comparison with another type will throw an exception.
* {@link http://www.w3.org/TR/rdf-sparql-query/#func-RDFterm-equal}
* <em>produces a type error if the arguments are both literal but are not the same RDF term</em>
*/
@@ -114,7 +115,7 @@
if (!v.isLiteral()) return false;
if (((ValueLiteral)v).isSimple()) {
// check values and language codes
- if (getValue().equals(v.getValue()) && compareLangEquals((ValueLiteral)v)) return true;
+ return getValue().equals(v.getValue()) && compareLangEquals((ValueLiteral)v);
}
throw new QueryException("Type Error: Terms are not equal");
}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/TypedLiteral.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/TypedLiteral.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/TypedLiteral.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -11,6 +11,7 @@
*/
package org.mulgara.query.filter.value;
+import java.math.BigDecimal;
import java.net.URI;
import java.util.Date;
import java.util.HashMap;
@@ -135,6 +136,9 @@
if (type == null) return ((String)value).length() != 0;
TypeInfo test = infoMap.get(type);
if (test == null) throw new QueryException("Type Error: no effective boolean value for: " + toString());
+ if (NumericLiteral.isNumeric(type)) {
+ return (value instanceof Number) && test.ebv((Number)value);
+ }
return test.ebv(value.toString());
}
@@ -149,6 +153,8 @@
public interface TypeInfo {
/** Returns an EBV of <code>true</code> iff the data matches the type sufficiently */
public boolean ebv(String data) throws QueryException;
+ /** Returns an EBV of <code>true</code> iff the number is not zero */
+ public boolean ebv(Number v) throws QueryException;
/** Returns data parsed out of the string literal */
public Object toData(String representation) throws QueryException;
/** Returns the URI for this type */
@@ -191,6 +197,7 @@
// initialize the types
static {
+ addDefaultTypeInfo(XSDDecimal.INSTANCE);
addDefaultTypeInfo(XSDString.INSTANCE);
addDefaultTypeInfo(XSDBoolean.INSTANCE);
addDefaultTypeInfo(XSDDouble.INSTANCE);
@@ -200,7 +207,6 @@
addDefaultTypeInfo(XSDShort.INSTANCE);
addDefaultTypeInfo(XSDByte.INSTANCE);
addDefaultTypeInfo(XSDDate.INSTANCE);
- infoMap.put(XSD.DECIMAL_URI, XSDLong.INSTANCE);
infoMap.put(XSD.INTEGER_URI, XSDLong.INSTANCE);
infoMap.put(XSD.NON_POSITIVE_INTEGER_URI, XSDLong.INSTANCE);
infoMap.put(XSD.NEGATIVE_INTEGER_URI, XSDLong.INSTANCE);
@@ -210,7 +216,6 @@
infoMap.put(XSD.UNSIGNED_INT_URI, XSDLong.INSTANCE);
infoMap.put(XSD.UNSIGNED_SHORT_URI, XSDInteger.INSTANCE);
infoMap.put(XSD.UNSIGNED_BYTE_URI, XSDShort.INSTANCE);
- infoMap.put(XSDAbbrev.DECIMAL_URI, XSDLong.INSTANCE);
infoMap.put(XSDAbbrev.INTEGER_URI, XSDLong.INSTANCE);
infoMap.put(XSDAbbrev.NON_POSITIVE_INTEGER_URI, XSDLong.INSTANCE);
infoMap.put(XSDAbbrev.NEGATIVE_INTEGER_URI, XSDLong.INSTANCE);
@@ -230,6 +235,7 @@
public static final XSDString INSTANCE = new XSDString();
private XSDString() { super(XSD.STRING_URI, XSDAbbrev.STRING_URI); }
public boolean ebv(String data) { return data != null && data.length() != 0; }
+ public boolean ebv(Number data) { throw new IllegalArgumentException("Found a number in a string operation"); }
public Object toData(String r) { return r; }
public ValueLiteral newLiteral(Object data) { return new TypedLiteral((String)data, getTypeURI()); }
}
@@ -238,10 +244,41 @@
public static final XSDBoolean INSTANCE = new XSDBoolean();
private XSDBoolean() { super(XSD.BOOLEAN_URI, XSDAbbrev.BOOLEAN_URI); }
public boolean ebv(String data) { return Boolean.parseBoolean(data); }
+ public boolean ebv(Number data) { throw new IllegalArgumentException("Found a number in a boolean operation"); }
public Object toData(String r) { return Boolean.parseBoolean(r); }
public ValueLiteral newLiteral(Object data) { return new Bool((Boolean)data); }
}
+ private static class XSDDecimal extends AbstractXSD {
+ public static final XSDDecimal INSTANCE = new XSDDecimal();
+ private XSDDecimal() { super(XSD.DECIMAL_URI, XSDAbbrev.DECIMAL_URI); }
+ public boolean ebv(String data) {
+ try {
+ if (data == null) return false;
+ BigDecimal d = new BigDecimal(data);
+ return !BigDecimal.ZERO.equals(d);
+ } catch (NumberFormatException nfe) {
+ return false;
+ }
+ }
+ public boolean ebv(Number data) {
+ return !BigDecimal.ZERO.equals(((BigDecimal)data));
+ }
+ public Object toData(String r) throws QueryException {
+ try {
+ return new BigDecimal(r);
+ } catch (NumberFormatException nfe) {
+ throw new QueryException("Type Error: Cannot convert to a Decimal: " + r);
+ }
+ }
+ public ValueLiteral newLiteral(Object data) {
+ if (data instanceof Double) return new NumericLiteral((Double)data, getTypeURI());
+ if (data instanceof Long) return new NumericLiteral((Long)data, getTypeURI());
+ return new NumericLiteral((BigDecimal)data, getTypeURI());
+ }
+ public Number valueOf(Number n) { return n.doubleValue(); }
+ }
+
private static class XSDDouble extends AbstractXSD {
public static final XSDDouble INSTANCE = new XSDDouble();
private XSDDouble() { super(XSD.DOUBLE_URI, XSDAbbrev.DOUBLE_URI); }
@@ -254,6 +291,7 @@
return false;
}
}
+ public boolean ebv(Number data) { return data.doubleValue() != 0.0D; }
public Object toData(String r) throws QueryException {
try {
return Double.parseDouble(r);
@@ -279,6 +317,7 @@
return false;
}
}
+ public boolean ebv(Number data) { return data.floatValue() != 0.0; }
public Object toData(String r) throws QueryException {
try {
return Float.parseFloat(r);
@@ -302,6 +341,7 @@
return false;
}
}
+ public boolean ebv(Number data) { return data.longValue() != 0L; }
public Object toData(String r) throws QueryException {
try {
return Long.parseLong(r);
@@ -325,6 +365,7 @@
return false;
}
}
+ public boolean ebv(Number data) { return data.intValue() != 0; }
public Object toData(String r) throws QueryException {
try {
return Integer.parseInt(r);
@@ -348,6 +389,7 @@
return false;
}
}
+ public boolean ebv(Number data) { return data.shortValue() != 0; }
public Object toData(String r) throws QueryException {
try {
return Short.parseShort(r);
@@ -371,9 +413,10 @@
return false;
}
}
+ public boolean ebv(Number data) { return data.byteValue() != 0; }
public Object toData(String r) throws QueryException {
try {
- return Long.parseLong(r);
+ return Byte.parseByte(r);
} catch (NumberFormatException nfe) {
throw new QueryException("Type Error: Cannot convert to a Byte: " + r);
}
@@ -388,6 +431,7 @@
public static final XSDDate INSTANCE = new XSDDate();
private XSDDate() { super(XSD.DATE_TIME_URI, XSDAbbrev.DATE_TIME_URI); }
public boolean ebv(String data) throws QueryException { throw new QueryException("Unable to convert a date to a boolean"); }
+ public boolean ebv(Number data) throws QueryException { throw new QueryException("Unable to convert a date to a boolean"); }
public Object toData(String r) { return DateTime.parseDate(r); }
public ValueLiteral newLiteral(Object data) { return new DateTime((Date)data); }
}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/Var.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/Var.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/Var.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -114,11 +114,6 @@
}
/** {@inheritDoc} */
- public boolean notEquals(RDFTerm v) throws QueryException {
- return resolve().notEquals(v);
- }
-
- /** {@inheritDoc} */
public boolean greaterThan(ComparableExpression v) throws QueryException {
return resolveComparable().greaterThan(v);
}
Modified: trunk/src/jar/query/java/org/mulgara/query/filter/value/VarUnitTest.java
===================================================================
--- trunk/src/jar/query/java/org/mulgara/query/filter/value/VarUnitTest.java 2009-03-10 07:40:57 UTC (rev 1601)
+++ trunk/src/jar/query/java/org/mulgara/query/filter/value/VarUnitTest.java 2009-03-12 06:48:30 UTC (rev 1602)
@@ -100,7 +100,6 @@
assertEquals(foo.getLexicalForm(), v.getLexical());
assertEquals(SimpleLiteral.STRING_TYPE, v.getType());
assertTrue(v.equals(new SimpleLiteral("foo")));
- assertFalse(v.notEquals(new SimpleLiteral("foo")));
assertTrue(v.greaterThan(new SimpleLiteral("eoo")));
assertTrue(v.greaterThanEqualTo(new SimpleLiteral("eoo")));
assertTrue(v.lessThan(new SimpleLiteral("goo")));
@@ -137,7 +136,6 @@
} catch (QueryException e) { }
IRI i = new IRI(foobar.getURI());
assertTrue(v.equals(i));
- assertFalse(v.notEquals(i));
SimpleLiteral s = new SimpleLiteral("foobar");
try {
@@ -196,7 +194,6 @@
} catch (QueryException e) { }
BlankNodeValue b = new BlankNodeValue(bn);
assertTrue(v.equals(b));
- assertFalse(v.notEquals(b));
SimpleLiteral s = new SimpleLiteral("foobar");
try {
@@ -262,10 +259,6 @@
v.equals(b);
assertTrue(false);
} catch (QueryException e) { }
- try {
- v.notEquals(b);
- assertTrue(false);
- } catch (QueryException e) { }
SimpleLiteral s = new SimpleLiteral("foobar");
try {
More information about the Mulgara-svn
mailing list