private static int MakeupFunctions(PreparedQuerySelectColumns columnSet, IList<SqlExpression> aggregateFunctions, out SqlExpression[] defFunList, out string[] defFunNames)
        {
            // Make up the functions list,
            var functionsList = columnSet.FunctionColumns.ToList();
            int fsz = functionsList.Count;
            var completeFunList = new List<object>();
            for (int i = 0; i < fsz; ++i) {
                var scol = functionsList[i];
                completeFunList.Add(scol.Expression);
                completeFunList.Add(scol.InternalName.Name);
            }

            for (int i = 0; i < aggregateFunctions.Count; ++i) {
                completeFunList.Add(aggregateFunctions[i]);
                completeFunList.Add("HAVINGAGG_" + (i + 1));
            }

            int fsz2 = completeFunList.Count / 2;
            defFunList = new SqlExpression[fsz2];
            defFunNames = new string[fsz2];
            for (int i = 0; i < fsz2; ++i) {
                defFunList[i] = (SqlExpression)completeFunList[i * 2];
                defFunNames[i] = (string)completeFunList[(i * 2) + 1];
            }

            return fsz;
        }

        public WhileLoopStatement(SqlExpression conditionExpression)
        {
            if (conditionExpression == null)
                throw new ArgumentNullException("conditionExpression");

            ConditionExpression = conditionExpression;
        }

        public override SqlExpression Visit(SqlExpression expression)
        {
            if (expression is QueryReferenceExpression)
                VisitQueryReference((QueryReferenceExpression) expression);

            return base.Visit(expression);
        }

 public void JoinAt(int betweenIndex, JoinType joinType, SqlExpression onExpression)
 {
     var planLeft = tablePlans[betweenIndex];
     var planRight = tablePlans[betweenIndex + 1];
     planLeft.RightJoin(planRight, joinType, onExpression);
     planRight.LeftJoin(planLeft, joinType, onExpression);
 }

        public string ToSqlString(SqlExpression expression)
        {
            rootQuery = expression is SqlQueryExpression;

            Visit(expression);
            return builder.ToString();
        }

 public JoinNode(IQueryPlanNode left, IQueryPlanNode right, ObjectName leftColumnName, SqlExpressionType @operator, SqlExpression rightExpression)
     : base(left, right)
 {
     LeftColumnName = leftColumnName;
     Operator = @operator;
     RightExpression = rightExpression;
 }

 public SimpleSelectNode(IQueryPlanNode child, ObjectName columnName, SqlExpressionType op, SqlExpression expression)
     : base(child)
 {
     ColumnName = columnName;
     OperatorType = op;
     Expression = expression;
 }

        public SetPasswordAction(SqlExpression passwordExpression)
        {
            if (passwordExpression == null)
                throw new ArgumentNullException("passwordExpression");

            PasswordExpression = passwordExpression;
        }

        public InvokeArgument(string name, SqlExpression value)
        {
            if (value == null)
                throw new ArgumentNullException("value");

            Name = name;
            Value = value;
        }

        /// <summary>
        /// Constructs a new <see cref="SelectColumn"/> for the given
        /// expression and aliased with the given name.
        /// </summary>
        /// <param name="expression">The <see cref="Expression"/> used for select
        /// a column within a <c>SELECT</c> statement.</param>
        /// <param name="alias">The name to alias the resulted expression.</param>
        public SelectColumn(SqlExpression expression, string alias)
        {
            if (expression == null)
                throw new ArgumentNullException("expression");

            Expression = expression;
            Alias = alias;
        }

        public ExpressionReference(SqlExpression expression, string @alias)
        {
            if (expression == null)
                throw new ArgumentNullException("expression");

            Alias = alias;
            Expression = expression;
        }

 public GroupNode(IQueryPlanNode child, ObjectName[] columnNames, ObjectName groupMaxColumn, SqlExpression[] functions, string[] names)
     : base(child)
 {
     ColumnNames = columnNames;
     GroupMaxColumn = groupMaxColumn;
     Functions = functions;
     Names = names;
 }

        internal CheckViolationException(ObjectName tableName, string constraintName, SqlExpression expression,
			ConstraintDeferrability deferrability)
            : base(SystemErrorCodes.CheckViolation, FormatMessage(tableName, constraintName, expression, deferrability))
        {
            TableName = tableName;
            ConstraintName = constraintName;
            CheckExpression = expression;
            Deferrability = deferrability;
        }

        internal JoinPart(JoinType joinType, SqlQueryExpression subQuery, SqlExpression onExpression)
        {
            if (subQuery == null)
                throw new ArgumentNullException("subQuery");

            OnExpression = onExpression;
            JoinType = joinType;
            SubQuery = subQuery;
        }

        public FunctionTable(ITable table, SqlExpression[] functionList, string[] columnNames, IRequest queryContext)
            : base(queryContext.Context)
        {
            // Make sure we are synchronized over the class.
            lock (typeof(FunctionTable)) {
                uniqueId = uniqueKeySeq;
                ++uniqueKeySeq;
            }

            uniqueId = (uniqueId & 0x0FFFFFFF) | 0x010000000;

            context = queryContext;

            ReferenceTable = table;
            varResolver = table.GetVariableResolver();
            varResolver = varResolver.ForRow(0);

            // Create a DataTableInfo object for this function table.
            funTableInfo = new TableInfo(FunctionTableName);

            expList = new SqlExpression[functionList.Length];
            expInfo = new byte[functionList.Length];

            // Create a new DataColumnInfo for each expression, and work out if the
            // expression is simple or not.
            for (int i = 0; i < functionList.Length; ++i) {
                var expr = functionList[i];
                // Examine the expression and determine if it is simple or not
                if (expr.IsConstant() && !expr.HasAggregate(context)) {
                    // If expression is a constant, solve it
                    var result = expr.Evaluate(context, null);
                    if (result.ExpressionType != SqlExpressionType.Constant)
                        throw new InvalidOperationException();

                    expr = result;
                    expList[i] = expr;
                    expInfo[i] = 1;
                } else {
                    // Otherwise must be dynamic
                    expList[i] = expr;
                    expInfo[i] = 0;
                }

                // Make the column info
                funTableInfo.AddColumn(columnNames[i], expr.ReturnType(context, varResolver));
            }

            // Make sure the table info isn't changed from this point on.
            funTableInfo = funTableInfo.AsReadOnly();

            // routine tables are the size of the referring table.
            rowCount = table.RowCount;

            // Set schemes to 'blind search'.
            SetupIndexes(DefaultIndexTypes.BlindSearch);
        }

        public SelectIntoStatement(SqlQueryExpression queryExpression, SqlExpression reference)
        {
            if (queryExpression == null)
                throw new ArgumentNullException("queryExpression");
            if (reference == null)
                throw new ArgumentNullException("reference");

            QueryExpression = queryExpression;
            Reference = reference;
        }

        internal SqlAssignExpression(SqlExpression reference, SqlExpression valueExpression)
        {
            if (reference == null)
                throw new ArgumentNullException("reference");
            if (valueExpression == null)
                throw new ArgumentNullException("valueExpression");

            ValueExpression = valueExpression;
            Reference = reference;
        }

        public CreateUserStatement(string userName, SqlExpression password)
        {
            if (password == null)
                throw new ArgumentNullException("password");
            if (String.IsNullOrEmpty(userName))
                throw new ArgumentNullException("userName");

            UserName = userName;
            Password = password;
        }

        public SqlColumnAssignment(string columnName, SqlExpression expression)
        {
            if (expression == null)
                throw new ArgumentNullException("expression");
            if (String.IsNullOrEmpty(columnName))
                throw new ArgumentNullException("columnName");

            ColumnName = columnName;
            Expression = expression;
        }

        public override void VisitBinaryExpression(SqlBinaryExpressionNode expressionNode)
        {
            var left = Build(expressionNode.Left);
            var right = Build(expressionNode.Right);
            var op = expressionNode.Operator;

            var expType = GetBinaryExpressionType(op);

            outputExpression = SqlExpression.Binary(left, expType, right);
        }