public ITable EvaluateAggregate(QueryProcessor processor, bool distinct, ITable group, Expression[] args)
        {
            if (!function.IsAggregate)
                throw new InvalidOperationException("The function is not an aggregate.");

            try {
                // Execute it
                object[] funArgs;
                if (invokeType == 6) {
                    funArgs = new object[] { function.Name, processor, distinct, group, args };
                }
                    // The QueryProcessor, Expression[] construct
                else if (invokeType == 1) {
                    funArgs = new object[] { processor, distinct, group, args };
                } else {
                    throw new ApplicationException("Unknown invoke type");
                }

                return (ITable)method.Invoke(null, funArgs);
            } catch (MethodAccessException e) {
                throw new ApplicationException(e.Message, e);
            } catch (TargetInvocationException e) {
                throw new ApplicationException(e.InnerException.Message, e.InnerException);
            }
        }

 public static ITable If(QueryProcessor processor, Expression[] args)
 {
     SqlObject[] conditional = QueryProcessor.Result(processor.Execute(args[0]));
     // If it evaluated to true,
     bool? b = conditional[0].Value.ToBoolean();
     return b != null && b == true ? processor.Execute(args[1]) : processor.Execute(args[2]);
 }

        public static ITable Length(QueryProcessor processor, Expression[] args)
        {
            if (args.Length != 1)
                throw new ArgumentException("The function LENGTH accepts only 1 argument.");

            Expression arg = args[0];

            SqlObject resultLength;
            SqlObject obj = QueryProcessor.Result(processor.Execute(arg))[0];
            if (obj.IsNull) {
                resultLength = SqlObject.MakeNull(SqlType.Numeric);
            } else {
                int length;
                SqlType obType = obj.Type;
                SqlValue obValue = obj.Value;
                // If it's a string,
                if (obType.IsString) {
                    length = obValue.ToString().Length;
                }
                    // If it's a binary,
                else if (obType.IsBinary) {
                    length = obValue.Length - 1;
                }
                    // Otherwise, return null,
                else {
                    length = -1;
                }

                resultLength = length == -1 ? SqlObject.MakeNull(SqlType.Numeric) : new SqlObject((long) length);
            }

            return QueryProcessor.ResultTable(resultLength);
        }

 public FilterExpression(string name, Expression child, Expression filter)
     : base(ExpressionType.Filter)
 {
     SetArgument("name", name);
     SetArgument("child", child);
     SetArgument("filter", filter);
 }

        public static ITable GroupConcat(QueryProcessor processor, bool distinct, ITable group, Expression[] args)
        {
            // The output string
            StringBuilder return_string = new StringBuilder();

            // Find the distinct subset of group
            if (distinct)
                group = processor.DistinctSubset(group, args);

            // Push the group table onto the processor stack
            processor.PushTable(group);

            // Iterator over the group
            IRowCursor i = group.GetRowCursor();
            bool first = true;
            while (i.MoveNext()) {
                RowId rowid = i.Current;
                processor.UpdateTableRow(rowid);
                foreach (Expression op in args) {
                    ITable val = processor.Execute(op);
                    SqlObject ob = QueryProcessor.Result(val)[0];
                    if (!ob.IsNull) {
                        if (!first) {
                            return_string.Append(", ");
                        }
                        return_string.Append(SqlValue.FromObject(ob.Value).ToString());
                        first = false;
                    }
                }
            }

            // Pop the table and return the result
            processor.PopTable();
            return QueryProcessor.ResultTable(new SqlObject(return_string.ToString()));
        }

 public AliasTableNameExpression(Expression child, TableName alias, SqlType returnType)
     : base(ExpressionType.AliasTableName)
 {
     SetArgument("child", child);
     SetArgument("alias", alias);
     if (returnType != null)
         SetArgument("return_type", returnType);
 }

        public static ITable Avg(QueryProcessor processor, bool distinct, ITable group, Expression[] args)
        {
            // Aggregate function only can have 1 argument
            if (args.Length > 1)
                throw new ArgumentException("Only one argument permitted for SUM function.");

            return ProcessAggregate(processor, distinct, group, args, new AvgAggregateInspector());
        }

 private static string GetActionString(Expression expression)
 {
     if (expression is FetchStaticExpression) {
         SqlObject val = (SqlObject)expression.GetArgument("static");
         return val.ToString();
     }
     throw new ApplicationException("Expecting static expression");
 }

 public JoinExpression(Expression left, Expression right, JoinType type, Expression filter)
     : this()
 {
     SetArgument("left", left);
     SetArgument("right", right);
     SetArgument("type", type);
     if (filter != null)
         SetArgument("filter", filter);
 }

 public UpdatableResultSetView(SystemTransaction transaction, IMutableTable backedTable, Expression[] project, IRowCursor select)
 {
     this.transaction = transaction;
     this.backedTable = backedTable;
     this.project = project;
     originalSelect = select;
     currentSelect = select;
     this.select = null;
 }

        public static Expression WalkGraph(Expression op, IGraphInspector inspector)
        {
            // The pre walk call
            op = inspector.OnBeforeWalk(op);

            ExpressionType type = op.Type;
            switch (type) {
                case ExpressionType.Function:
                    InspectParamList(inspector, op, "param_count", "arg");
                    break;

                case ExpressionType.Select:
                    InspectParam(inspector, op, "join");
                    InspectParam(inspector, op, "filter");
                    InspectParam(inspector, op, "havingfilter");
                    InspectParamList(inspector, op, "out_count", "out");
                    InspectParamList(inspector, op, "groupby_count", "groupby");
                    InspectParamList(inspector, op, "orderby_count", "orderby");
                    break;

                case ExpressionType.Join:
                    InspectParam(inspector, op, "left");
                    InspectParam(inspector, op, "right");
                    InspectParam(inspector, op, "filter");
                    break;

                // Single passthrough
                case ExpressionType.AliasTableName:
                case ExpressionType.AliasVariableName:
                    InspectParam(inspector, op, "child");
                    break;
                case ExpressionType.Filter:
                    InspectParam(inspector, op, "child");
                    InspectParam(inspector, op, "filter");
                    break;

                // Terminators
                case ExpressionType.FetchVariable:
                case ExpressionType.FetchStatic:
                case ExpressionType.FetchParameter:
                case ExpressionType.FetchGlob:
                case ExpressionType.FetchTable:
                    break;

                default:
                    throw new ArgumentException("Unknown operation " + op.Type);
            }

            // The post expression call
            op = inspector.OnAfterWalk(op);

            // Return the operation
            return op;
        }

        public ITable Evaluate(QueryProcessor processor, Expression[] args)
        {
            // 'CAST' is a special case,
            if (function.Name.Equals("@cast")) {
                // Get the value to cast, and the type to cast it to,
                SqlObject val = QueryProcessor.Result(processor.Execute(args[0]))[0];
                SqlObject castType = QueryProcessor.Result(processor.Execute(args[1]))[0];

                string castTypeString = castType.Value.ToString();
                SqlType type = SqlType.Parse(castTypeString);

                // Do the cast,
                SqlObject result = val.CastTo(type);

                // And return the result,
                return QueryProcessor.ResultTable(result);
            }

            if (function.IsAggregate)
                throw new InvalidOperationException("The function is aggregate.");

            try {
                // Execute it
                if (invokeType == 6) {
                    object[] funArgs = { function.Name, processor, args };
                    return (ITable)method.Invoke(null, funArgs);
                }
                    // The QueryProcessor, Expression[] construct
                if (invokeType == 1) {
                    object[] funArgs = { processor, args };
                    return (ITable)method.Invoke(null, funArgs);
                }
                    // The SqlObject construct
                if (invokeType == 2) {
                    int sz = args.Length;
                    // Resolve the arguments into TypedValues
                    SqlObject[] obs = new SqlObject[sz];
                    for (int i = 0; i < sz; ++i) {
                        obs[i] = QueryProcessor.Result(processor.Execute(args[i]))[0];
                    }
                    // Set up the arguments and invoke the method
                    object[] funArgs = { obs };
                    SqlObject result = (SqlObject)method.Invoke(null, funArgs);
                    // Wrap on a FunctionTable and return
                    return QueryProcessor.ResultTable(result);
                }

                throw new ApplicationException("Unknown invoke type");
            } catch (MethodAccessException e) {
                throw new ApplicationException(e.Message, e);
            } catch (TargetInvocationException e) {
                throw new ApplicationException(e.InnerException.Message, e.InnerException);
            }
        }

        private static void CostAggregateFilterOp(Expression child, FilterExpression expression)
        {
            // The child cost values
            double childRows = child.CostRows;
            double childTime = child.CostTime;

            // TODO: We should check for full range aggregate, in which case we
            //   know there will only be 1 row result.

            // Set the costs
            expression.CostTime = childTime + (childRows * 1);
            expression.CostRows = childRows;
        }

        public static ITable Least(QueryProcessor processor, Expression[] args)
        {
            SqlObject least = null;
            for (int i = 0; i < args.Length; ++i) {
                SqlObject ob = QueryProcessor.Result(processor.Execute(args[i]))[0];
                if (ob.IsNull)
                    return QueryProcessor.ResultTable(ob);

                if (least == null || SqlObject.Compare(ob, least) < 0)
                    least = ob;
            }

            return QueryProcessor.ResultTable(least);
        }

        public void Cost(Expression expression, double currentBestTime, int[] walkIteration)
        {
            // If this already has costing information, return
            if (expression.IsCostSet)
                return;

            ++walkIteration[0];

            if (expression is FilterExpression) {
                // Cost the child
                Expression childExp = ((FilterExpression)expression).Child;
                Cost(childExp, currentBestTime, walkIteration);
                if (!childExp.IsCostSet ||
                    IsCostWorse(currentBestTime, childExp)) {
                    return;
                }

                // Cost the filter operation
                CostFilterExpression(childExp, expression);
            } else if (expression is JoinExpression) {
                JoinExpression joinExp = (JoinExpression) expression;

                // Cost the left and right operations
                Expression left = joinExp.Left;
                Expression right = joinExp.Right;

                Cost(left, currentBestTime, walkIteration);
                if (!left.IsCostSet || IsCostWorse(currentBestTime, left))
                    return;

                Cost(right, currentBestTime, walkIteration);
                if (!right.IsCostSet || IsCostWorse(currentBestTime, right))
                    return;

                // Cost the join operation
                CostJoinExpression(left, right, joinExp);
            } else if (expression is AliasTableNameExpression) {
                // Fetch the table, apply the alias, and update the cost information.
                // The cost in time is 0 for a fetch operation because no scan operations
                // are necessary.
                ITable table = ExecuteExpression(expression);
                expression.CostTime = 0;
                expression.CostRows = table.RowCount;
            } else if (expression is FunctionExpression) {
                // Function should already be costed
                return;
            } else {
                throw new ApplicationException("Unrecognized operation type");
            }
        }

        public void AddColumn(string label, SqlType type, Expression expr)
        {
            OutputExpression outExpr = new OutputExpression();
            outExpr.label = label;
            outExpr.type = type;
            outExpr.expression = expr;
            // If the expression is a 'FETCHVAR' type then we pass it through the
            // blob accessor methods in hopes of not having to materialize large
            // objects.
            if (expr is FetchVariableExpression)
                outExpr.var = ((FetchVariableExpression)expr).Variable;

            outputExps.Add(outExpr);
        }

        private static bool IsDeferrable(Expression op)
        {
            if (op is FetchStaticExpression) {
                SqlObject val = (SqlObject)op.GetArgument("static");
                string str = val.ToString();
                if (str.Equals("deferrable"))
                    return true;
                if (str.Equals("not deferrable"))
                    return false;

                throw new ApplicationException("Unexpected deferrability type '" + str + "'");
            }

            throw new ApplicationException("Expecting static expression");
        }

        private static bool IsDeferred(Expression expression)
        {
            if (expression is FetchStaticExpression) {
                SqlObject val = (SqlObject)expression.GetArgument("static");
                string str = val.ToString();
                if (str.Equals("initially deferred"))
                    return true;
                if (str.Equals("initially immediate"))
                    return false;

                throw new ApplicationException("Unexpected initial check type '" + str + "'");
            }

            throw new ApplicationException("Expecting static expression");
        }

        public static ITable Count(QueryProcessor processor, bool distinct, ITable group, Expression[] args)
        {
            // Only 1 argument allowed
            if (args.Length > 1)
                throw new ArgumentException("Only one argument permitted for COUNT function.");

            // If the parameter is a function operation with name "star" then this is
            // a simple group size result
            Expression arg = args[0];
            if (arg.Type == ExpressionType.Function &&
                arg.GetArgument("name").Equals("star")) {
                return QueryProcessor.ResultTable(SqlObject.CastTo(group.RowCount, SqlType.Numeric));
            }

            // Otherwise, if this is a distinct,
            if (distinct) {
                group = processor.DistinctSubset(group, args);
                // The above process removes null values so we return the count,
                return QueryProcessor.ResultTable(SqlObject.CastTo(group.RowCount, SqlType.Numeric));
            }

            // Otherwise, we need to iterate through a count all none null values,
            return ProcessAggregate(processor, false, group, args, new CountAggregateInspector());
        }

        public void ClearGraph(Expression expression)
        {
            // The graph should only have 'FETCHTABLE', 'JOIN', 'FILTER' and 'FUNCTION'
            // operations in the graph.  The FUNCTION expressions are themselves other
            // costed operation graphs.
            if (expression is FilterExpression) {
                // Recurse to the child
                ClearGraph(((FilterExpression)expression).Child);
            } else if (expression is JoinExpression) {
                JoinExpression joinExp = (JoinExpression) expression;
                // Recurse the left and right nodes
                ClearGraph(joinExp.Left);
                ClearGraph(joinExp.Right);
            } else if (expression is AliasTableNameExpression) {
            } else if (expression is FunctionExpression) {
                // This does not have costing information we should clear
                return;
            } else {
                throw new ApplicationException("Unknown operation type in graph.");
            }

            // Clear the costing information
            expression.UnsetCost();
        }