diff --git a/src/main/java/com/samskivert/depot/Funcs.java b/src/main/java/com/samskivert/depot/Funcs.java
index 0ca46e3..e40076a 100644
--- a/src/main/java/com/samskivert/depot/Funcs.java
+++ b/src/main/java/com/samskivert/depot/Funcs.java
@@ -32,21 +32,25 @@ import com.samskivert.depot.impl.expression.StringFun.*;
 public class Funcs
 {
     /**
-     * Creates an aggregate expression that averages all values from the supplied expression.
-     * This would usually be used in a FieldOverride and supplied with a ColumnExp.
+     * Creates an aggregate expression that averages all values from the supplied expression. Note
+     * that this method forces the result to type {@link Number} because databases may perform
+     * widening under the hood, and using Number allows the application to do the appropriate
+     * conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> average (SQLExpression<T> expr)
+    public static FluentExp<Number> average (SQLExpression<? extends Number> expr)
     {
-        return new Average<T>(expr);
+        return new Average<Number>(expr);
     }
 
     /**
-     * Creates an expression that averages all distinct values from the supplied expression.
-     * This would usually be used in a FieldOverride and supplied with a ColumnExp.
+     * Creates an expression that averages all distinct values from the supplied expression. Note
+     * that this method forces the result to type {@link Number} because databases may perform
+     * widening under the hood, and using Number allows the application to do the appropriate
+     * conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> averageDistinct (SQLExpression<T> expr)
+    public static FluentExp<Number> averageDistinct (SQLExpression<? extends Number> expr)
     {
-        return new Average<T>(expr, true);
+        return new Average<Number>(expr, true);
     }
 
     /**
@@ -99,12 +103,14 @@ public class Funcs
     }
 
     /**
-     * Creates an aggregate expression that sums all the values from the supplied expression.
-     * This would usually be used in a FieldOverride and supplied with a ColumnExp.
+     * Creates an aggregate expression that sums all the values from the supplied expression. Note
+     * that this method forces the result to type {@link Number} because databases may perform
+     * widening under the hood, and using Number allows the application to do the appropriate
+     * conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> sum (SQLExpression<T> expr)
+    public static FluentExp<Number> sum (SQLExpression<? extends Number> expr)
     {
-        return new Sum<T>(expr);
+        return new Sum<Number>(expr);
     }
 
     /**
@@ -161,7 +167,7 @@ public class Funcs
     /**
      * Creates an expression that evaluates to the length of the supplied array column.
      */
-    public static FluentExp<Integer> arrayLength (SQLExpression<?> exp)
+    public static FluentExp<Number> arrayLength (SQLExpression<?> exp)
     {
         return new Length(exp);
     }
diff --git a/src/main/java/com/samskivert/depot/MathFuncs.java b/src/main/java/com/samskivert/depot/MathFuncs.java
index 7e8c0d3..417d95f 100644
--- a/src/main/java/com/samskivert/depot/MathFuncs.java
+++ b/src/main/java/com/samskivert/depot/MathFuncs.java
@@ -38,47 +38,63 @@ public class MathFuncs
     }
 
     /**
-     * Creates an expression that computes the integer ceiling of the supplied expression.
+     * Creates an expression that computes the integer ceiling of the supplied expression. Note
+     * that this method forces the result to type {@link Number} because databases may perform
+     * widening or conversion under the hood, and using Number allows the application to do the
+     * appropriate conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> ceil (SQLExpression<T> exp)
+    public static FluentExp<Number> ceil (SQLExpression<? extends Number> exp)
     {
-        return new Ceil<T>(exp);
+        return new Ceil<Number>(exp);
     }
 
     /**
-     * Creates an expression that computes the exponential of the supplied expression.
+     * Creates an expression that computes the integer floor of the supplied expression. Note that
+     * this method forces the result to type {@link Number} because databases may perform widening
+     * or conversion under the hood, and using Number allows the application to do the appropriate
+     * conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> exp (SQLExpression<T> exp)
+    public static FluentExp<Number> floor (SQLExpression<? extends Number> exp)
     {
-        return new Exp<T>(exp);
+        return new Floor<Number>(exp);
     }
 
     /**
-     * Creates an expression that computes the integer floor of the supplied expression.
+     * Creates an expression that computes the exponential of the supplied expression. Note that
+     * this method forces the result to type {@link Number} because databases may perform widening
+     * or conversion under the hood, and using Number allows the application to do the appropriate
+     * conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> floor (SQLExpression<T> exp)
+    public static FluentExp<Number> exp (SQLExpression<? extends Number> exp)
     {
-        return new Floor<T>(exp);
+        return new Exp<Number>(exp);
     }
 
     /**
-     * Creates an expression that computes the natural logarithm of the supplied expression.
+     * Creates an expression that computes the natural logarithm of the supplied expression. Note
+     * that this method forces the result to type {@link Number} because databases may perform
+     * widening or conversion under the hood, and using Number allows the application to do the
+     * appropriate conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> ln (SQLExpression<T> exp)
+    public static FluentExp<Number> ln (SQLExpression<? extends Number> exp)
     {
-        return new Ln<T>(exp);
+        return new Ln<Number>(exp);
     }
 
     /**
-     * Creates an expression that computes the base-10 logarithm of the supplied expression.
+     * Creates an expression that computes the base-10 logarithm of the supplied expression. Note
+     * that this method forces the result to type {@link Number} because databases may perform
+     * widening or conversion under the hood, and using Number allows the application to do the
+     * appropriate conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> log10 (SQLExpression<T> value)
+    public static FluentExp<Number> log10 (SQLExpression<? extends Number> value)
     {
-        return new Log10<T>(value);
+        return new Log10<Number>(value);
     }
 
     /**
-     * Creates an expression that evaluates to the constant PI.
+     * Creates an expression that evaluates to the constant PI. You will need to manually specify
+     * the type your database returns for PI if you plan on actually selecting this value.
      */
     public static <T extends Number> FluentExp<T> pi ()
     {
@@ -86,16 +102,21 @@ public class MathFuncs
     }
 
     /**
-     * Creates an expression that computes the value expression to the given power.
+     * Creates an expression that computes the value expression to the given power. Note that this
+     * method forces the result to type {@link Number} because databases may perform widening or
+     * conversion under the hood, and using Number allows the application to do the appropriate
+     * conversion at runtime.
      */
-    public static <R extends Number, P extends Number> FluentExp<R> power (SQLExpression<R> value,
-                                                                           SQLExpression<P> power)
+    public static FluentExp<Number> power (SQLExpression<? extends Number> value,
+                                           SQLExpression<? extends Number> power)
     {
-        return new Power<R, P>(value, power);
+        return new Power<Number>(value, power);
     }
 
     /**
-     * Creates an expression that returns a random number between 0.0 and 1.0.
+     * Creates an expression that returns a random number between 0.0 and 1.0. You will need to
+     * manually specify the type your database returns for random values if you plan on actually
+     * selecting this value.
      */
     public static <T extends Number> FluentExp<T> random ()
     {
@@ -103,35 +124,46 @@ public class MathFuncs
     }
 
     /**
-     * Creates an expression that computes the whole number nearest the supplied expression.
+     * Creates an expression that computes the whole number nearest the supplied expression. Note
+     * that this method forces the result to type {@link Number} because databases may perform
+     * widening or conversion under the hood, and using Number allows the application to do the
+     * appropriate conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> round (SQLExpression<T> exp)
+    public static FluentExp<Number> round (SQLExpression<? extends Number> exp)
     {
-        return new Round<T>(exp);
+        return new Round<Number>(exp);
     }
 
     /**
-     * Creates an expression that computes the sign of the supplied expression.
+     * Creates an expression that computes the sign of the supplied expression. Note that this
+     * method forces the result to type {@link Number} because databases may perform widening or
+     * conversion under the hood, and using Number allows the application to do the appropriate
+     * conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> sign (SQLExpression<T> exp)
+    public static FluentExp<Number> sign (SQLExpression<? extends Number> exp)
     {
-        return new Sign<T>(exp);
+        return new Sign<Number>(exp);
     }
 
     /**
-     * Creates an expression that computes the square root of the supplied expression.
+     * Creates an expression that computes the square root of the supplied expression. Note that
+     * this method forces the result to type {@link Number} because databases may perform widening
+     * or conversion under the hood, and using Number allows the application to do the appropriate
+     * conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> sqrt (SQLExpression<T> exp)
+    public static FluentExp<Number> sqrt (SQLExpression<? extends Number> exp)
     {
-        return new Sqrt<T>(exp);
+        return new Sqrt<Number>(exp);
     }
 
     /**
-     * Creates an expression that computes the truncation of the supplied expression,
-     * i.e. the next closest whole number to zero.
+     * Creates an expression that computes the truncation of the supplied expression, i.e. the next
+     * closest whole number to zero. Note that this method forces the result to type {@link Number}
+     * because databases may perform widening or conversion under the hood, and using Number allows
+     * the application to do the appropriate conversion at runtime.
      */
-    public static <T extends Number> FluentExp<T> trunc (SQLExpression<T> exp)
+    public static FluentExp<Number> trunc (SQLExpression<? extends Number> exp)
     {
-        return new Trunc<T>(exp);
+        return new Trunc<Number>(exp);
     }
 }
diff --git a/src/main/java/com/samskivert/depot/StringFuncs.java b/src/main/java/com/samskivert/depot/StringFuncs.java
index 38348c3..8d03c95 100644
--- a/src/main/java/com/samskivert/depot/StringFuncs.java
+++ b/src/main/java/com/samskivert/depot/StringFuncs.java
@@ -32,7 +32,7 @@ public class StringFuncs
     /**
      * Creates an expression that evaluates to the string length of the supplied expression.
      */
-    public static FluentExp<Integer> length (SQLExpression<String> exp)
+    public static FluentExp<Number> length (SQLExpression<String> exp)
     {
         return new Length(exp);
     }
@@ -49,8 +49,8 @@ public class StringFuncs
      * Creates an expression that locates the given substring expression within the given
      * string expression and returns the index.
      */
-    public static FluentExp<Integer> position (SQLExpression<String> substring,
-                                               SQLExpression<String> string)
+    public static FluentExp<Number> position (SQLExpression<String> substring,
+                                              SQLExpression<String> string)
     {
         return new Position(substring, string);
     }
@@ -59,8 +59,18 @@ public class StringFuncs
      * Creates an expression that evaluates to a substring of the given string expression,
      * starting at the given index and of the given length.
      */
-    public static FluentExp<String> substring (
-        SQLExpression<String> string, SQLExpression<String> from, SQLExpression<Integer> count)
+    public static FluentExp<String> substring (SQLExpression<String> string, int from, int count)
+    {
+        return new Substring(string, Exps.value(from), Exps.value(count));
+    }
+
+    /**
+     * Creates an expression that evaluates to a substring of the given string expression,
+     * starting at the given index and of the given length.
+     */
+    public static FluentExp<String> substring (SQLExpression<String> string,
+                                               SQLExpression<Integer> from,
+                                               SQLExpression<Integer> count)
     {
         return new Substring(string, from, count);
     }
diff --git a/src/main/java/com/samskivert/depot/impl/BuildVisitor.java b/src/main/java/com/samskivert/depot/impl/BuildVisitor.java
index 26dcd24..635263a 100644
--- a/src/main/java/com/samskivert/depot/impl/BuildVisitor.java
+++ b/src/main/java/com/samskivert/depot/impl/BuildVisitor.java
@@ -594,7 +594,7 @@ public abstract class BuildVisitor implements FragmentVisitor<Void>
         return appendFunctionCall("PI");
     }
 
-    public Void visit (Power<?,?> exp)
+    public Void visit (Power<?> exp)
     {
         return appendFunctionCall("power", exp.getValue(), exp.getPower());
     }
diff --git a/src/main/java/com/samskivert/depot/impl/ExpressionEvaluator.java b/src/main/java/com/samskivert/depot/impl/ExpressionEvaluator.java
index 96744b9..b7c6e6e 100644
--- a/src/main/java/com/samskivert/depot/impl/ExpressionEvaluator.java
+++ b/src/main/java/com/samskivert/depot/impl/ExpressionEvaluator.java
@@ -371,7 +371,7 @@ public class ExpressionEvaluator
         throw new IllegalArgumentException("Can't evaluate expression: " + exp);
     }
 
-    public Void visit (Power<?,?> exp)
+    public Void visit (Power<?> exp)
     {
         throw new IllegalArgumentException("Can't evaluate expression: " + exp);
     }
diff --git a/src/main/java/com/samskivert/depot/impl/FragmentVisitor.java b/src/main/java/com/samskivert/depot/impl/FragmentVisitor.java
index 67ffa95..1bb5e16 100644
--- a/src/main/java/com/samskivert/depot/impl/FragmentVisitor.java
+++ b/src/main/java/com/samskivert/depot/impl/FragmentVisitor.java
@@ -124,7 +124,7 @@ public interface FragmentVisitor<T>
     public T visit (Ln<?> exp);
     public T visit (Log10<?> exp);
     public T visit (Pi<?> exp);
-    public T visit (Power<?,?> exp);
+    public T visit (Power<?> exp);
     public T visit (Random<?> exp);
     public T visit (Round<?> exp);
     public T visit (Sign<?> exp);
diff --git a/src/main/java/com/samskivert/depot/impl/HSQLBuilder.java b/src/main/java/com/samskivert/depot/impl/HSQLBuilder.java
index dc9c23e..c740fd6 100644
--- a/src/main/java/com/samskivert/depot/impl/HSQLBuilder.java
+++ b/src/main/java/com/samskivert/depot/impl/HSQLBuilder.java
@@ -30,6 +30,8 @@ import com.google.common.collect.Lists;
 
 import com.samskivert.jdbc.ColumnDefinition;
 import com.samskivert.util.ArrayUtil;
+
+import com.samskivert.depot.Exps;
 import com.samskivert.depot.Ops;
 import com.samskivert.depot.PersistentRecord;
 import com.samskivert.depot.annotation.FullTextIndex;
@@ -37,10 +39,14 @@ import com.samskivert.depot.annotation.GeneratedValue;
 import com.samskivert.depot.expression.*;
 import com.samskivert.depot.operator.FullText;
 
+import com.samskivert.depot.impl.expression.AggregateFun;
 import com.samskivert.depot.impl.expression.DateFun.DatePart.Part;
 import com.samskivert.depot.impl.expression.DateFun.DatePart;
 import com.samskivert.depot.impl.expression.DateFun.DateTruncate;
+import com.samskivert.depot.impl.expression.LiteralExp;
+import com.samskivert.depot.impl.expression.NumericalFun;
 import com.samskivert.depot.impl.expression.StringFun.Lower;
+import com.samskivert.depot.impl.expression.ValueExp;
 import com.samskivert.depot.impl.operator.BitAnd;
 import com.samskivert.depot.impl.operator.BitOr;
 import com.samskivert.depot.impl.operator.Like;
@@ -51,6 +57,41 @@ public class HSQLBuilder
 {
     public class HBuildVisitor extends BuildVisitor
     {
+        @Override public Void visit (AggregateFun.Average<?> exp)
+        {
+            return appendAggregateFunctionCall("avg", exp);
+        }
+
+        @Override public Void visit (NumericalFun.Round<?> exp)
+        {
+            // HSQLDB requires a number of digits after the decimal place argument, so we supply
+            // zero to emulate round on other databases
+            return appendFunctionCall("round", exp.getArg(), Exps.value(0));
+        }
+
+        @Override public Void visit (NumericalFun.Trunc<?> exp)
+        {
+            // TODO: this would work if HSQLDB truncate actually worked, but it doesn't; we'll
+            // leave it in here in case some future bug fixed version of HSQLDB does work
+            return appendFunctionCall("truncate", exp.getArg(), Exps.value(0));
+        }
+
+        @Override public Void visit (NumericalFun.Random<?> exp)
+        {
+            return appendFunctionCall("rand");
+        }
+
+        @Override public Void visit (NumericalFun.Power<?> exp)
+        {
+            // HSQLDB can't handle a value argument to power(a, b), so we turn the ValueExp into a
+            // LiteralExp
+            SQLExpression<?> power = exp.getPower();
+            if (power instanceof ValueExp<?>) {
+                power = new LiteralExp<String>(((ValueExp<?>)power).getValue().toString());
+            }
+            return appendFunctionCall("power", exp.getValue(), power);
+        }
+
         @Override public Void visit (FullText.Match match)
         {
             // HSQL doesn't have real full text search, so we fake it by creating a condition like
diff --git a/src/main/java/com/samskivert/depot/impl/expression/AggregateFun.java b/src/main/java/com/samskivert/depot/impl/expression/AggregateFun.java
index 4838123..0cad4e1 100644
--- a/src/main/java/com/samskivert/depot/impl/expression/AggregateFun.java
+++ b/src/main/java/com/samskivert/depot/impl/expression/AggregateFun.java
@@ -27,10 +27,10 @@ import com.samskivert.depot.impl.expression.Function.OneArgFun;
 public abstract class AggregateFun<T> extends OneArgFun<T>
 {
     public static class Average<T extends Number> extends AggregateFun<T> {
-        public Average (SQLExpression<T> argument) {
+        public Average (SQLExpression<? extends T> argument) {
             this(argument, false);
         }
-        public Average (SQLExpression<T> argument, boolean distinct) {
+        public Average (SQLExpression<? extends T> argument, boolean distinct) {
             super(argument, distinct);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -72,10 +72,10 @@ public abstract class AggregateFun<T> extends OneArgFun<T>
     }
 
     public static class Max<T extends Number> extends AggregateFun<T> {
-        public Max (SQLExpression<T> argument) {
+        public Max (SQLExpression<? extends T> argument) {
             this(argument, false);
         }
-        public Max (SQLExpression<T> argument, boolean distinct) {
+        public Max (SQLExpression<? extends T> argument, boolean distinct) {
             super(argument, distinct);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -87,10 +87,10 @@ public abstract class AggregateFun<T> extends OneArgFun<T>
     }
 
     public static class Min<T extends Number> extends AggregateFun<T> {
-        public Min (SQLExpression<T> argument) {
+        public Min (SQLExpression<? extends T> argument) {
             this(argument, false);
         }
-        public Min (SQLExpression<T> argument, boolean distinct) {
+        public Min (SQLExpression<? extends T> argument, boolean distinct) {
             super(argument, distinct);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -102,10 +102,10 @@ public abstract class AggregateFun<T> extends OneArgFun<T>
     }
 
     public static class Sum<T extends Number> extends AggregateFun<T> {
-        public Sum (SQLExpression<T> argument) {
+        public Sum (SQLExpression<? extends T> argument) {
             this(argument, false);
         }
-        public Sum (SQLExpression<T> argument, boolean distinct) {
+        public Sum (SQLExpression<? extends T> argument, boolean distinct) {
             super(argument, distinct);
         }
         public Object accept (FragmentVisitor<?> visitor) {
diff --git a/src/main/java/com/samskivert/depot/impl/expression/NumericalFun.java b/src/main/java/com/samskivert/depot/impl/expression/NumericalFun.java
index 8997c7c..dfdc7fa 100644
--- a/src/main/java/com/samskivert/depot/impl/expression/NumericalFun.java
+++ b/src/main/java/com/samskivert/depot/impl/expression/NumericalFun.java
@@ -29,7 +29,7 @@ import com.samskivert.depot.impl.expression.Function.TwoArgFun;
 public abstract class NumericalFun
 {
     public static class Abs<T extends Number> extends OneArgFun<T> {
-        public Abs (SQLExpression<T> argument) {
+        public Abs (SQLExpression<? extends T> argument) {
             super(argument);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -41,7 +41,7 @@ public abstract class NumericalFun
     }
 
     public static class Ceil<T extends Number> extends OneArgFun<T> {
-        public Ceil (SQLExpression<T> argument) {
+        public Ceil (SQLExpression<? extends T> argument) {
             super(argument);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -53,7 +53,7 @@ public abstract class NumericalFun
     }
 
     public static class Exp<T extends Number> extends OneArgFun<T> {
-        public Exp (SQLExpression<T> argument) {
+        public Exp (SQLExpression<? extends T> argument) {
             super(argument);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -65,7 +65,7 @@ public abstract class NumericalFun
     }
 
     public static class Floor<T extends Number> extends OneArgFun<T> {
-        public Floor (SQLExpression<T> argument) {
+        public Floor (SQLExpression<? extends T> argument) {
             super(argument);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -77,7 +77,7 @@ public abstract class NumericalFun
     }
 
     public static class Ln<T extends Number> extends OneArgFun<T> {
-        public Ln (SQLExpression<T> argument) {
+        public Ln (SQLExpression<? extends T> argument) {
             super(argument);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -89,7 +89,7 @@ public abstract class NumericalFun
     }
 
     public static class Log10<T extends Number> extends OneArgFun<T> {
-        public Log10 (SQLExpression<T> value) {
+        public Log10 (SQLExpression<? extends T> value) {
             super(value);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -109,8 +109,8 @@ public abstract class NumericalFun
         }
     }
 
-    public static class Power<R extends Number,P extends Number> extends TwoArgFun<R> {
-        public Power (SQLExpression<R> value, SQLExpression<P> power) {
+    public static class Power<T extends Number> extends TwoArgFun<T> {
+        public Power (SQLExpression<? extends T> value, SQLExpression<? extends Number> power) {
             super(value, power);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -137,7 +137,7 @@ public abstract class NumericalFun
     }
 
     public static class Round<T extends Number> extends OneArgFun<T> {
-        public Round (SQLExpression<T> argument) {
+        public Round (SQLExpression<? extends T> argument) {
             super(argument);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -149,7 +149,7 @@ public abstract class NumericalFun
     }
 
     public static class Sign<T extends Number> extends OneArgFun<T> {
-        public Sign (SQLExpression<T> argument) {
+        public Sign (SQLExpression<? extends T> argument) {
             super(argument);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -161,7 +161,7 @@ public abstract class NumericalFun
     }
 
     public static class Sqrt<T extends Number> extends OneArgFun<T> {
-        public Sqrt (SQLExpression<T> argument) {
+        public Sqrt (SQLExpression<? extends T> argument) {
             super(argument);
         }
         public Object accept (FragmentVisitor<?> visitor) {
@@ -173,7 +173,7 @@ public abstract class NumericalFun
     }
 
     public static class Trunc<T extends Number> extends OneArgFun<T> {
-        public Trunc (SQLExpression<T> argument) {
+        public Trunc (SQLExpression<? extends T> argument) {
             super(argument);
         }
         public Object accept (FragmentVisitor<?> visitor) {
diff --git a/src/main/java/com/samskivert/depot/impl/expression/StringFun.java b/src/main/java/com/samskivert/depot/impl/expression/StringFun.java
index cbf48b8..ab94515 100644
--- a/src/main/java/com/samskivert/depot/impl/expression/StringFun.java
+++ b/src/main/java/com/samskivert/depot/impl/expression/StringFun.java
@@ -28,7 +28,7 @@ import com.samskivert.depot.impl.expression.Function.TwoArgFun;
 
 public abstract class StringFun
 {
-    public static class Length extends OneArgFun<Integer> {
+    public static class Length extends OneArgFun<Number> {
         // can take both String or array types (anything that turns into byte[])
         public Length (SQLExpression<?> argument) {
             super(argument);
@@ -53,7 +53,7 @@ public abstract class StringFun
         }
     }
 
-    public static class Position extends TwoArgFun<Integer> {
+    public static class Position extends TwoArgFun<Number> {
         public Position (SQLExpression<String> substring, SQLExpression<String> string) {
             super(substring, string);
         }
@@ -72,8 +72,8 @@ public abstract class StringFun
     }
 
     public static class Substring extends ManyArgFun<String> {
-        public Substring (SQLExpression<String> string, SQLExpression<String> from,
-                          SQLExpression<Integer> count) {
+        public Substring (SQLExpression<String> string,
+                          SQLExpression<Integer> from, SQLExpression<Integer> count) {
             super(string, from, count);
         }
         public Object accept (FragmentVisitor<?> visitor) {
diff --git a/src/test/java/com/samskivert/depot/ProjectionTest.java b/src/test/java/com/samskivert/depot/ProjectionTest.java
index be1cb53..f060d15 100644
--- a/src/test/java/com/samskivert/depot/ProjectionTest.java
+++ b/src/test/java/com/samskivert/depot/ProjectionTest.java
@@ -108,13 +108,6 @@ public class ProjectionTest extends TestBase
 
     @Test public void testAggregates ()
     {
-        // test computed expressions on the RHS (the casts are just to cope with JUnit's overloads)
-        assertEquals(9, (int)_repo.from(TestRecord.class).load(Funcs.max(TestRecord.RECORD_ID)));
-        assertEquals(10, (int)_repo.from(TestRecord.class).load(Funcs.count(TestRecord.RECORD_ID)));
-        assertEquals(0, (int)_repo.from(TestRecord.class).load(Funcs.min(TestRecord.RECORD_ID)));
-        assertEquals(Tuple2.create(9, 0), _repo.from(TestRecord.class).load(
-                         Funcs.max(TestRecord.RECORD_ID), Funcs.min(TestRecord.RECORD_ID)));
-
         List<Tuple2<String, Integer>> ewant = Lists.newArrayList();
         ewant.add(Tuple2.create("Abraham", 1));
         ewant.add(Tuple2.create("Elvis", 2));
@@ -124,6 +117,84 @@ public class ProjectionTest extends TestBase
                      select(EnumKeyRecord.NAME, Funcs.count(EnumKeyRecord.TYPE)));
     }
 
+    @Test public void testFuncs ()
+    {
+        Query<TestRecord> query = _repo.from(TestRecord.class);
+
+        assertEquals(4, query.load(Funcs.average(TestRecord.RECORD_ID)).intValue());
+        assertEquals(4, query.load(Funcs.averageDistinct(TestRecord.RECORD_ID)).intValue());
+
+        assertEquals(10, query.load(Funcs.count(TestRecord.RECORD_ID)).intValue());
+        assertEquals(false, query.load(Funcs.every(TestRecord.RECORD_ID.greaterThan(5))));
+        assertEquals(true, query.load(Funcs.every(TestRecord.RECORD_ID.lessThan(100))));
+
+        assertEquals(9, query.load(Funcs.max(TestRecord.RECORD_ID)).intValue());
+        assertEquals(0, query.load(Funcs.min(TestRecord.RECORD_ID)).intValue());
+        assertEquals(45, query.load(Funcs.sum(TestRecord.RECORD_ID)).intValue());
+
+        // TODO: not sure what a good test for Funcs.coalesce() is...
+
+        List<Integer> greatest = Lists.newArrayList(99, 99, 99, 99, 99, 99, 99, 99, 99, 99);
+        assertEquals(greatest, query.select(Funcs.greatest(TestRecord.RECORD_ID, TestRecord.AGE)));
+
+        List<Integer> least = Lists.newArrayList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+        assertEquals(least, query.select(Funcs.least(TestRecord.RECORD_ID, TestRecord.AGE)));
+
+        // length(blob) not supported by HSQLDB
+        // assertEquals(4*5, (int)query.select(Funcs.arrayLength(TestRecord.NUMBERS)));
+    }
+
+    @Test public void testStringFuncs ()
+    {
+        Query<TestRecord> first = _repo.from(TestRecord.class).where(TestRecord.RECORD_ID.eq(1));
+
+        assertEquals(5, first.load(StringFuncs.length(TestRecord.NAME)).intValue());
+        assertEquals("elvis", first.load(StringFuncs.lower(TestRecord.NAME)));
+        assertEquals(3, first.load(StringFuncs.position(
+                                       Exps.value("vis"), TestRecord.NAME)).intValue());
+        assertEquals("lvi", first.load(StringFuncs.substring(TestRecord.NAME, 2, 3)));
+        assertEquals("Elvis", first.load(StringFuncs.trim(TestRecord.NAME)));
+        assertEquals("ELVIS", first.load(StringFuncs.upper(TestRecord.NAME)));
+    }
+
+    @Test public void testMathFuncs ()
+    {
+        Query<TestRecord> first = _repo.from(TestRecord.class).where(TestRecord.RECORD_ID.eq(1));
+
+        assertEquals(99, first.load(MathFuncs.abs(TestRecord.AGE)).intValue());
+        assertEquals(1f, first.load(MathFuncs.ceil(TestRecord.AWESOMENESS)).floatValue(), 0);
+        assertEquals(0f, first.load(MathFuncs.floor(TestRecord.AWESOMENESS)).floatValue(), 0);
+
+        assertEquals(Math.exp(0.75), first.load(
+                         MathFuncs.exp(TestRecord.AWESOMENESS)).doubleValue(), 0.0001);
+
+        assertEquals(Math.log(0.75), first.load(
+                         MathFuncs.ln(TestRecord.AWESOMENESS)).doubleValue(), 0.0001);
+
+        assertEquals(Math.PI, first.load(MathFuncs.<Double>pi()), 0.0001);
+
+        assertTrue(first.load(MathFuncs.<Double>random()) < 1.0);
+
+        assertEquals(1, first.load(MathFuncs.round(TestRecord.AWESOMENESS)).intValue());
+        assertEquals(1, first.load(MathFuncs.sign(TestRecord.AWESOMENESS)).intValue());
+        assertEquals(Math.sqrt(0.75), first.load(
+                         MathFuncs.sqrt(TestRecord.AWESOMENESS)).doubleValue(), 0.0001);
+
+        assertEquals(Math.pow(0.75f, 10), first.load(
+                         MathFuncs.power(TestRecord.AWESOMENESS, Exps.value(10))).doubleValue(),
+                     0.0001);
+
+        // HSQLDB log10 seems not to work either, it returns some wildly incorrect value
+        // assertEquals(Math.log10(0.75), first.load(
+        //                  MathFuncs.log10(TestRecord.AWESOMENESS)).doubleValue(), 0.0001);
+
+        // HSQLDB truncate(a,b) simply doesn't work, if you supply trunacte(a, >=0) then you get
+        // back a regardless of the number of decimal places a contains or the number you requested
+        // to truncate to, and if you supply truncate(a, <0) you get back 0 regardless of a
+        // assertEquals(0, first.load(
+        //                  MathFuncs.trunc(TestRecord.AWESOMENESS)).doubleValue(), 0.0001);
+    }
+
     // the HSQL in-memory database persists for the lifetime of the VM, which means we have to
     // clean up after ourselves in every test; thus we go ahead and share a repository
     protected TestRepository _repo = createTestRepository();
diff --git a/src/test/java/com/samskivert/depot/TestBase.java b/src/test/java/com/samskivert/depot/TestBase.java
index 4e939d9..1470017 100644
--- a/src/test/java/com/samskivert/depot/TestBase.java
+++ b/src/test/java/com/samskivert/depot/TestBase.java
@@ -73,6 +73,7 @@ public abstract class TestBase
         rec.recordId = recordId;
         rec.name = "Elvis";
         rec.age = 99;
+        rec.awesomeness = 0.75f;
         rec.created = now;
         rec.homeTown = "Right here";
         rec.type = EnumKeyRecord.Type.A;
@@ -89,6 +90,7 @@ public abstract class TestBase
         assertEquals(expect.recordId, got.recordId);
         assertEquals(expect.name, got.name);
         assertEquals(expect.age, got.age);
+        assertEquals(expect.awesomeness, got.awesomeness, 0);
         assertEquals(expect.created, got.created);
         assertEquals(expect.homeTown, got.homeTown);
         assertEquals(expect.type, got.type);
diff --git a/src/test/java/com/samskivert/depot/TestRecord.java b/src/test/java/com/samskivert/depot/TestRecord.java
index 27513e5..d9bda9d 100644
--- a/src/test/java/com/samskivert/depot/TestRecord.java
+++ b/src/test/java/com/samskivert/depot/TestRecord.java
@@ -41,6 +41,7 @@ public class TestRecord extends PersistentRecord
     public static final ColumnExp<Integer> RECORD_ID = colexp(_R, "recordId");
     public static final ColumnExp<String> NAME = colexp(_R, "name");
     public static final ColumnExp<Integer> AGE = colexp(_R, "age");
+    public static final ColumnExp<Float> AWESOMENESS = colexp(_R, "awesomeness");
     public static final ColumnExp<String> HOME_TOWN = colexp(_R, "homeTown");
     public static final ColumnExp<EnumKeyRecord.Type> TYPE = colexp(_R, "type");
     public static final ColumnExp<Date> CREATED = colexp(_R, "created");
@@ -57,6 +58,8 @@ public class TestRecord extends PersistentRecord
 
     public int age;
 
+    public float awesomeness;
+
     public String homeTown;
 
     public EnumKeyRecord.Type type;