[Mulgara-svn] r1595 - trunk/src/jar/querylang/java/org/mulgara/sparql

pag at mulgara.org pag at mulgara.org
Mon Mar 9 19:26:54 UTC 2009


Author: pag
Date: 2009-03-09 12:26:53 -0700 (Mon, 09 Mar 2009)
New Revision: 1595

Modified:
   trunk/src/jar/querylang/java/org/mulgara/sparql/FilterMapper.java
Log:
Fixed bug to allow for comparisons between comparable types, and not just numbers

Modified: trunk/src/jar/querylang/java/org/mulgara/sparql/FilterMapper.java
===================================================================
--- trunk/src/jar/querylang/java/org/mulgara/sparql/FilterMapper.java	2009-03-07 19:37:59 UTC (rev 1594)
+++ trunk/src/jar/querylang/java/org/mulgara/sparql/FilterMapper.java	2009-03-09 19:26:53 UTC (rev 1595)
@@ -78,6 +78,7 @@
 import org.mulgara.query.filter.arithmetic.MinusOperation;
 import org.mulgara.query.filter.arithmetic.MultiplyOperation;
 import org.mulgara.query.filter.value.Bool;
+import org.mulgara.query.filter.value.ComparableExpression;
 import org.mulgara.query.filter.value.DataTypeFn;
 import org.mulgara.query.filter.value.ExternalFn;
 import org.mulgara.query.filter.value.IRI;
@@ -180,6 +181,18 @@
   }
 
   /**
+   * Converts a CST ComparableExpression into an AST ComparableExpression.
+   * @param operand The CST comparable expression.
+   * @return An AST comparable expression.
+   * @throws MulgaraParserException If the value was not mapped to an AST numeric expression.
+   */
+  static private ComparableExpression mapComparable(Expression operand) throws MulgaraParserException {
+    RDFTerm op = mapExpression(operand);
+    if (!(op instanceof ComparableExpression)) throw new MulgaraParserException("Non-comparable value in comparison operation: " + op.getClass().getSimpleName());
+    return (ComparableExpression)op;
+  }
+
+  /**
    * Converts a CST Expression into an AST value that resolves to a literal ({@link ValueLiteral}).
    * @param operand The CST expression.
    * @return An AST value expression.
@@ -404,28 +417,28 @@
   private static class GreaterThanMap extends AbstractExprToFilter<GreaterThan> {
     public Class<GreaterThan> getMapType() { return GreaterThan.class; }
     public RDFTerm typedMap(GreaterThan expr) throws MulgaraParserException {
-      return new org.mulgara.query.filter.GreaterThan(mapNumber(expr.getLhs()), mapNumber(expr.getRhs()));
+      return new org.mulgara.query.filter.GreaterThan(mapComparable(expr.getLhs()), mapComparable(expr.getRhs()));
     }
   }
 
   private static class GreaterThanEqualMap extends AbstractExprToFilter<GreaterThanEqual> {
     public Class<GreaterThanEqual> getMapType() { return GreaterThanEqual.class; }
     public RDFTerm typedMap(GreaterThanEqual expr) throws MulgaraParserException {
-      return new GreaterThanEqualTo(mapNumber(expr.getLhs()), mapNumber(expr.getRhs()));
+      return new GreaterThanEqualTo(mapComparable(expr.getLhs()), mapComparable(expr.getRhs()));
     }
   }
 
   private static class LessThanMap extends AbstractExprToFilter<LessThan> {
     public Class<LessThan> getMapType() { return LessThan.class; }
     public RDFTerm typedMap(LessThan expr) throws MulgaraParserException {
-      return new org.mulgara.query.filter.LessThan(mapNumber(expr.getLhs()), mapNumber(expr.getRhs()));
+      return new org.mulgara.query.filter.LessThan(mapComparable(expr.getLhs()), mapComparable(expr.getRhs()));
     }
   }
 
   private static class LessThanEqualMap extends AbstractExprToFilter<LessThanEqual> {
     public Class<LessThanEqual> getMapType() { return LessThanEqual.class; }
     public RDFTerm typedMap(LessThanEqual expr) throws MulgaraParserException {
-      return new LessThanEqualTo(mapNumber(expr.getLhs()), mapNumber(expr.getRhs()));
+      return new LessThanEqualTo(mapComparable(expr.getLhs()), mapComparable(expr.getRhs()));
     }
   }
 




More information about the Mulgara-svn mailing list