mono/mcs/class/referencesource/System.Data.Linq/SqlClient/Common/SqlNode.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Linq.Expressions;
using System.Diagnostics;
using System.Data;

namespace System.Data.Linq.SqlClient {
    using System.Data.Linq.Mapping;
    using System.Data.Linq.Provider;
    using System.Diagnostics.CodeAnalysis;

    internal enum SqlNodeType {
        Add,
        Alias,
        AliasRef,
        And,
        Assign,
        Avg,
        Between,
        BitAnd,
        BitNot,
        BitOr,
        BitXor,
        Block,
        ClientArray,
        ClientCase,
        ClientParameter,
        ClientQuery,
        ClrLength,
        Coalesce,
        Column,
        ColumnRef,
        Concat,
        Convert,
        Count,
        Delete,
        DiscriminatedType,
        DiscriminatorOf,
        Div,
        DoNotVisit,
        Element,
        ExprSet,
        EQ,
        EQ2V,
        Exists,
        FunctionCall,
        In,
        IncludeScope,
        IsNotNull,
        IsNull,
        LE,
        Lift,
        Link,
        Like,
        LongCount,
        LT,
        GE,
        Grouping,
        GT,
        Insert,
        Join,
        JoinedCollection,
        Max,
        MethodCall,
        Member,
        MemberAssign,
        Min,
        Mod,
        Mul,
        Multiset,
        NE,
        NE2V,
        Negate,
        New,
        Not,
        Not2V,
        Nop,
        Or,
        OptionalValue,
        OuterJoinedValue,
        Parameter,
        Property,
        Row,
        RowNumber,
        ScalarSubSelect,
        SearchedCase,
        Select,
        SharedExpression,
        SharedExpressionRef,
        SimpleCase,
        SimpleExpression,
        Stddev,
        StoredProcedureCall,
        Sub,
        Sum,
        Table,
        TableValuedFunctionCall,
        Treat,
        TypeCase,
        Union,
        Update,
        UserColumn,
        UserQuery,
        UserRow,
        Variable,
        Value,
        ValueOf
    }

    [System.Diagnostics.DebuggerDisplay("text = {Text}, \r\nsource = {SourceExpression}")]
    internal abstract class SqlNode {
        private SqlNodeType nodeType;
        private Expression sourceExpression;

        internal SqlNode(SqlNodeType nodeType, Expression sourceExpression) {
            this.nodeType = nodeType;
            this.sourceExpression = sourceExpression;
        }

        internal Expression SourceExpression {
            get { return this.sourceExpression; }
        }

        internal void ClearSourceExpression() {
            this.sourceExpression = null;
        }

        internal SqlNodeType NodeType {
            get { return this.nodeType; }
        }

#if DEBUG
        private static DbFormatter formatter;
        internal static DbFormatter Formatter {
            get { return formatter; }
            set { formatter = value; }
        }

        internal string Text {
            get {
                if (Formatter == null)
                    return "SqlNode.Formatter is not assigned";
                return SqlNode.Formatter.Format(this, true);
            }
        }
#endif
    }

    internal abstract class SqlExpression : SqlNode {
        private Type clrType;
        internal SqlExpression(SqlNodeType nodeType, Type clrType, Expression sourceExpression)
            : base(nodeType, sourceExpression) {
            this.clrType = clrType;
        }

        internal Type ClrType {
            get { return this.clrType; }
        }

        // note: changing the CLR type of a node is potentially dangerous
        internal void SetClrType(Type type) {
            this.clrType = type;
        }

        internal abstract ProviderType SqlType { get; }

        /// <summary>
        /// Drill down looking for a constant root expression, returning true if found.
        /// </summary>           
        internal bool IsConstantColumn {
            get {
                if (this.NodeType == SqlNodeType.Column) {
                    SqlColumn col = (SqlColumn)this;
                    if (col.Expression != null) {
                        return col.Expression.IsConstantColumn;
                    }
                }
                else if (this.NodeType == SqlNodeType.ColumnRef) {
                    return ((SqlColumnRef)this).Column.IsConstantColumn;
                }
                else if (this.NodeType == SqlNodeType.OptionalValue) {
                    return ((SqlOptionalValue)this).Value.IsConstantColumn;
                }
                else if (this.NodeType == SqlNodeType.Value ||
                        this.NodeType == SqlNodeType.Parameter) {
                    return true;
                }
                return false;
            }
        }
    }

    /// <summary>
    /// A SqlExpression with a simple implementation of ClrType and SqlType.
    /// </summary>
    internal abstract class SqlSimpleTypeExpression : SqlExpression {
        private ProviderType sqlType;

        internal SqlSimpleTypeExpression(SqlNodeType nodeType, Type clrType, ProviderType sqlType, Expression sourceExpression)
            : base(nodeType, clrType, sourceExpression) {
            this.sqlType = sqlType;
        }

        internal override ProviderType SqlType {
            get { return this.sqlType; }
        }

        internal void SetSqlType(ProviderType type) {
            this.sqlType = type;
        }
    }

    internal class SqlDiscriminatorOf : SqlSimpleTypeExpression {
        SqlExpression obj;
        internal SqlDiscriminatorOf(SqlExpression obj, Type clrType, ProviderType sqlType, Expression sourceExpression)
            : base(SqlNodeType.DiscriminatorOf, clrType, sqlType, sourceExpression) {
            this.obj = obj;
        }
        internal SqlExpression Object {
            get { return this.obj; }
            set { this.obj = value; }
        }
    }


    /// <summary>
    /// Represents a dynamic CLR type that is chosen based on a discriminator expression.
    /// </summary>
    internal class SqlDiscriminatedType : SqlExpression {
        private ProviderType sqlType;
        private SqlExpression discriminator;
        private MetaType targetType;
        internal SqlDiscriminatedType(ProviderType sqlType, SqlExpression discriminator, MetaType targetType, Expression sourceExpression)
            : base(SqlNodeType.DiscriminatedType,
                   typeof(Type),
                   sourceExpression) {
            if (discriminator == null)
                throw Error.ArgumentNull("discriminator");
            this.discriminator = discriminator;
            this.targetType = targetType;
            this.sqlType = sqlType;
        }
        internal override ProviderType SqlType {
            get { return this.sqlType; }
        }
        internal SqlExpression Discriminator {
            get { return this.discriminator; }
            set { this.discriminator = value; }
        }

        internal MetaType TargetType {
            get { return this.targetType; }
        }
    }

    internal abstract class SqlStatement : SqlNode {
        internal SqlStatement(SqlNodeType nodeType, Expression sourceExpression)
            : base(nodeType, sourceExpression) {
        }
    }

    internal abstract class SqlSource : SqlNode {
        internal SqlSource(SqlNodeType nt, Expression sourceExpression)
            : base(nt, sourceExpression) {
        }
    }

    internal class SqlSelect : SqlStatement {
        private SqlExpression top;
        private bool isPercent;
        private bool isDistinct;
        private SqlExpression selection;
        private SqlRow row;
        private SqlSource from;
        private SqlExpression where;
        private List<SqlExpression> groupBy;
        private SqlExpression having;
        private List<SqlOrderExpression> orderBy;
        private SqlOrderingType orderingType;
        private bool squelch;

        internal SqlSelect(SqlExpression selection, SqlSource from, Expression sourceExpression)
            : base(SqlNodeType.Select, sourceExpression) {
            this.Row = new SqlRow(sourceExpression);
            this.Selection = selection;
            this.From = from;
            this.groupBy = new List<SqlExpression>();
            this.orderBy = new List<SqlOrderExpression>();
            this.orderingType = SqlOrderingType.Default;
        }

        internal SqlExpression Top {
            get { return this.top; }
            set { this.top = value; }
        }

        internal bool IsPercent {
            get { return this.isPercent; }
            set { this.isPercent = value; }
        }

        internal bool IsDistinct {
            get { return this.isDistinct; }
            set { this.isDistinct = value; }
        }

        internal SqlExpression Selection {
            get { return this.selection; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.selection = value;
            }
        }

        internal SqlRow Row {
            get { return this.row; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.row = value;
            }
        }

        internal SqlSource From {
            get { return this.from; }
            set { this.from = value; }
        }

        internal SqlExpression Where {
            get { return this.where; }
            set {
                if (value != null && TypeSystem.GetNonNullableType(value.ClrType) != typeof(bool)) {
                    throw Error.ArgumentWrongType("value", "bool", value.ClrType);
                }
                this.where = value;
            }
        }

        internal List<SqlExpression> GroupBy {
            get { return this.groupBy; }
        }

        internal SqlExpression Having {
            get { return this.having; }
            set {
                if (value != null && TypeSystem.GetNonNullableType(value.ClrType) != typeof(bool)) {
                    throw Error.ArgumentWrongType("value", "bool", value.ClrType);
                }
                this.having = value;
            }
        }

        internal List<SqlOrderExpression> OrderBy {
            get { return this.orderBy; }
        }

        internal SqlOrderingType OrderingType {
            get { return this.orderingType; }
            set { this.orderingType = value; }
        }

        internal bool DoNotOutput {
            get { return this.squelch; }
            set { this.squelch = value; }
        }
    }

    internal enum SqlOrderingType {
        Default,
        Never,
        Blocked,
        Always
    }

    internal class SqlTable : SqlNode {
        private MetaTable table;
        private MetaType rowType;
        private ProviderType sqlRowType;
        private List<SqlColumn> columns;

        internal SqlTable(MetaTable table, MetaType rowType, ProviderType sqlRowType, Expression sourceExpression)
            : base(SqlNodeType.Table, sourceExpression) {
            this.table = table;
            this.rowType = rowType;
            this.sqlRowType = sqlRowType;
            this.columns = new List<SqlColumn>();
        }

        internal MetaTable MetaTable {
            get { return this.table; }
        }

        internal string Name {
            get { return this.table.TableName; }
        }

        internal List<SqlColumn> Columns {
            get { return this.columns; }
        }

        internal MetaType RowType {
            get { return this.rowType; }
        }

        internal ProviderType SqlRowType {
            get { return this.sqlRowType; }
        }

        internal SqlColumn Find(string columnName) {
            foreach (SqlColumn c in this.Columns) {
                if (c.Name == columnName)
                    return c;
            }
            return null;
        }

    }

    internal class SqlUserQuery : SqlNode {
        private string queryText;
        private SqlExpression projection;
        private List<SqlExpression> args;
        private List<SqlUserColumn> columns;

        internal SqlUserQuery(SqlNodeType nt, SqlExpression projection, IEnumerable<SqlExpression> args, Expression source)
            : base(nt, source) {
            this.Projection = projection;
            this.args = (args != null) ? new List<SqlExpression>(args) : new List<SqlExpression>();
            this.columns = new List<SqlUserColumn>();
        }

        internal SqlUserQuery(string queryText, SqlExpression projection, IEnumerable<SqlExpression> args, Expression source)
            : base(SqlNodeType.UserQuery, source) {
            this.queryText = queryText;
            this.Projection = projection;
            this.args = (args != null) ? new List<SqlExpression>(args) : new List<SqlExpression>();
            this.columns = new List<SqlUserColumn>();
        }

        internal string QueryText {
            get { return this.queryText; }
        }

        internal SqlExpression Projection {
            get { return this.projection; }
            set {
                if (this.projection != null && this.projection.ClrType != value.ClrType)
                    throw Error.ArgumentWrongType("value", this.projection.ClrType, value.ClrType);
                this.projection = value;
            }
        }

        internal List<SqlExpression> Arguments {
            get { return this.args; }
        }

        internal List<SqlUserColumn> Columns {
            get { return this.columns; }
        }

        internal SqlUserColumn Find(string name) {
            foreach (SqlUserColumn c in this.Columns) {
                if (c.Name == name)
                    return c;
            }
            return null;
        }
    }

    internal class SqlStoredProcedureCall : SqlUserQuery {
        private MetaFunction function;

        internal SqlStoredProcedureCall(MetaFunction function, SqlExpression projection, IEnumerable<SqlExpression> args, Expression source)
            : base(SqlNodeType.StoredProcedureCall, projection, args, source) {
            if (function == null)
                throw Error.ArgumentNull("function");
            this.function = function;
        }

        internal MetaFunction Function {
            get { return this.function; }
        }
    }

    internal class SqlUserRow : SqlSimpleTypeExpression {
        private SqlUserQuery query;
        private MetaType rowType;

        internal SqlUserRow(MetaType rowType, ProviderType sqlType, SqlUserQuery query, Expression source)
            : base(SqlNodeType.UserRow, rowType.Type, sqlType, source) {
            this.Query = query;
            this.rowType = rowType;
        }

        internal MetaType RowType {
            get { return this.rowType; }
        }

        internal SqlUserQuery Query {
            get { return this.query; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (value.Projection != null && value.Projection.ClrType != this.ClrType)
                    throw Error.ArgumentWrongType("value", this.ClrType, value.Projection.ClrType);
                this.query = value;
            }
        }
    }

    internal class SqlUserColumn : SqlSimpleTypeExpression {
        private SqlUserQuery query;
        private string name;
        private bool isRequired;

        internal SqlUserColumn(Type clrType, ProviderType sqlType, SqlUserQuery query, string name, bool isRequired, Expression source)
            : base(SqlNodeType.UserColumn, clrType, sqlType, source) {
            this.Query = query;
            this.name = name;
            this.isRequired = isRequired;
        }

        internal SqlUserQuery Query {
            get { return this.query; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (this.query != null && this.query != value)
                    throw Error.ArgumentWrongValue("value");
                this.query = value;
            }
        }

        internal string Name {
            get { return this.name; }
        }

        internal bool IsRequired {
            get { return this.isRequired; }
        }
    }

    internal class SqlAlias : SqlSource {
        private string name;
        private SqlNode node;

        internal SqlAlias(SqlNode node)
            : base(SqlNodeType.Alias, node.SourceExpression) {
            this.Node = node;
        }

        internal string Name {
            get { return this.name; }
            set { this.name = value; }
        }

        internal SqlNode Node {
            get { return this.node; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (!(value is SqlExpression || value is SqlSelect || value is SqlTable || value is SqlUnion))
                    throw Error.UnexpectedNode(value.NodeType);
                this.node = value;
            }
        }
    }

    internal class SqlAliasRef : SqlExpression {
        private SqlAlias alias;

        internal SqlAliasRef(SqlAlias alias)
            : base(SqlNodeType.AliasRef, GetClrType(alias.Node), alias.SourceExpression) {
            if (alias == null)
                throw Error.ArgumentNull("alias");
            this.alias = alias;
        }

        internal SqlAlias Alias {
            get { return this.alias; }
        }

        internal override ProviderType SqlType {
            get { return GetSqlType(this.alias.Node); }
        }

        private static Type GetClrType(SqlNode node) {
            SqlTableValuedFunctionCall tvf = node as SqlTableValuedFunctionCall;
            if (tvf != null)
                return tvf.RowType.Type;
            SqlExpression exp = node as SqlExpression;
            if (exp != null) {
                if (TypeSystem.IsSequenceType(exp.ClrType))
                    return TypeSystem.GetElementType(exp.ClrType);
                return exp.ClrType;
            }
            SqlSelect sel = node as SqlSelect;
            if (sel != null)
                return sel.Selection.ClrType;
            SqlTable tab = node as SqlTable;
            if (tab != null)
                return tab.RowType.Type;
            SqlUnion su = node as SqlUnion;
            if (su != null)
                return su.GetClrType();
            throw Error.UnexpectedNode(node.NodeType);
        }

        private static ProviderType GetSqlType(SqlNode node) {
            SqlExpression exp = node as SqlExpression;
            if (exp != null)
                return exp.SqlType;
            SqlSelect sel = node as SqlSelect;
            if (sel != null)
                return sel.Selection.SqlType;
            SqlTable tab = node as SqlTable;
            if (tab != null)
                return tab.SqlRowType;
            SqlUnion su = node as SqlUnion;
            if (su != null)
                return su.GetSqlType();
            throw Error.UnexpectedNode(node.NodeType);
        }
    }

    internal class SqlJoin : SqlSource {
        private SqlJoinType joinType;
        private SqlSource left;
        private SqlSource right;
        private SqlExpression condition;

        internal SqlJoin(SqlJoinType type, SqlSource left, SqlSource right, SqlExpression cond, Expression sourceExpression)
            : base(SqlNodeType.Join, sourceExpression) {
            this.JoinType = type;
            this.Left = left;
            this.Right = right;
            this.Condition = cond;
        }

        internal SqlJoinType JoinType {
            get { return this.joinType; }
            set { this.joinType = value; }
        }

        internal SqlSource Left {
            get { return this.left; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.left = value;
            }
        }

        internal SqlSource Right {
            get { return this.right; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.right = value;
            }
        }

        internal SqlExpression Condition {
            get { return this.condition; }
            set { this.condition = value; }
        }
    }

    internal enum SqlJoinType {
        Cross,
        Inner,
        LeftOuter,
        CrossApply,
        OuterApply
    }

    internal class SqlUnion : SqlNode {
        private SqlNode left;
        private SqlNode right;
        private bool all;

        internal SqlUnion(SqlNode left, SqlNode right, bool all)
            : base(SqlNodeType.Union, right.SourceExpression) {
            this.Left = left;
            this.Right = right;
            this.All = all;
        }

        internal SqlNode Left {
            get { return this.left; }
            set {
                Validate(value);
                this.left = value;
            }
        }

        internal SqlNode Right {
            get { return this.right; }
            set {
                Validate(value);
                this.right = value;
            }
        }

        internal bool All {
            get { return this.all; }
            set { this.all = value; }
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
        private void Validate(SqlNode node) {
            if (node == null)
                throw Error.ArgumentNull("node");
            if (!(node is SqlExpression || node is SqlSelect || node is SqlUnion))
                throw Error.UnexpectedNode(node.NodeType);
        }

        internal Type GetClrType() {
            SqlExpression exp = this.Left as SqlExpression;
            if (exp != null)
                return exp.ClrType;
            SqlSelect sel = this.Left as SqlSelect;
            if (sel != null)
                return sel.Selection.ClrType;
            throw Error.CouldNotGetClrType();
        }

        internal ProviderType GetSqlType() {
            SqlExpression exp = this.Left as SqlExpression;
            if (exp != null)
                return exp.SqlType;
            SqlSelect sel = this.Left as SqlSelect;
            if (sel != null)
                return sel.Selection.SqlType;
            throw Error.CouldNotGetSqlType();
        }
    }

    internal class SqlNop : SqlSimpleTypeExpression {
        internal SqlNop(Type clrType, ProviderType sqlType, Expression sourceExpression)
            : base(SqlNodeType.Nop, clrType, sqlType, sourceExpression) {
        }
    }

    internal class SqlLift : SqlExpression {
        internal SqlExpression liftedExpression;

        internal SqlLift(Type type, SqlExpression liftedExpression, Expression sourceExpression)
            : base(SqlNodeType.Lift, type, sourceExpression) {
            if (liftedExpression == null)
                throw Error.ArgumentNull("liftedExpression");
            this.liftedExpression = liftedExpression;
        }

        internal SqlExpression Expression {
            get { return this.liftedExpression; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.liftedExpression = value;
            }
        }

        internal override ProviderType SqlType {
            get { return this.liftedExpression.SqlType; }
        }
    }

    internal enum SqlOrderType {
        Ascending,
        Descending
    }

    internal class SqlOrderExpression : IEquatable<SqlOrderExpression> {
        private SqlOrderType orderType;
        private SqlExpression expression;

        internal SqlOrderExpression(SqlOrderType type, SqlExpression expr) {
            this.OrderType = type;
            this.Expression = expr;
        }

        internal SqlOrderType OrderType {
            get { return this.orderType; }
            set { this.orderType = value; }
        }

        internal SqlExpression Expression {
            get { return this.expression; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (this.expression != null && !this.expression.ClrType.IsAssignableFrom(value.ClrType))
                    throw Error.ArgumentWrongType("value", this.expression.ClrType, value.ClrType);
                this.expression = value;
            }
        }

        public override bool Equals(object obj) {
            if (this.EqualsTo(obj as SqlOrderExpression))
                return true;

            return base.Equals(obj);
        }

        public bool Equals(SqlOrderExpression other) {
            if (this.EqualsTo(other))
                return true;

            return base.Equals(other);
        }

        private bool EqualsTo(SqlOrderExpression other) {
            if (other == null)
                return false;
            if (object.ReferenceEquals(this, other))
                return true;
            if (this.OrderType != other.OrderType)
                return false;
            if (!this.Expression.SqlType.Equals(other.Expression.SqlType))
                return false;

            SqlColumn col1 = SqlOrderExpression.UnwrapColumn(this.Expression);
            SqlColumn col2 = SqlOrderExpression.UnwrapColumn(other.Expression);

            if (col1 == null || col2 == null)
                return false;

            return col1 == col2;
        }

        public override int GetHashCode() {
            SqlColumn col = SqlOrderExpression.UnwrapColumn(this.Expression);
            if (col != null)
                return col.GetHashCode();

            return base.GetHashCode();
        }

        private static SqlColumn UnwrapColumn(SqlExpression expr) {
            System.Diagnostics.Debug.Assert(expr != null);

            SqlUnary exprAsUnary = expr as SqlUnary;
            if (exprAsUnary != null) {
                expr = exprAsUnary.Operand;
            }

            SqlColumn exprAsColumn = expr as SqlColumn;
            if (exprAsColumn != null) {
                return exprAsColumn;
            }

            SqlColumnRef exprAsColumnRef = expr as SqlColumnRef;
            if (exprAsColumnRef != null) {
                return exprAsColumnRef.GetRootColumn();
            }
            //
            // For all other types return null to revert to default behavior for Equals()
            // and GetHashCode()
            //
            return null;
        }
    }

    internal class SqlRowNumber : SqlSimpleTypeExpression {
        private List<SqlOrderExpression> orderBy;

        internal List<SqlOrderExpression> OrderBy {
            get { return orderBy; }
        }

        internal SqlRowNumber(Type clrType, ProviderType sqlType, List<SqlOrderExpression> orderByList, Expression sourceExpression)
            : base(SqlNodeType.RowNumber, clrType, sqlType, sourceExpression) {
            if (orderByList == null) {
                throw Error.ArgumentNull("orderByList");
            }

            this.orderBy = orderByList;
        }
    }

    internal class SqlUnary : SqlSimpleTypeExpression {
        private SqlExpression operand;
        private MethodInfo method;

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification="These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
        internal SqlUnary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression expr, Expression sourceExpression)
            : this(nt, clrType, sqlType, expr, null, sourceExpression) {
        }

        internal SqlUnary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression expr, MethodInfo method, Expression sourceExpression)
            : base(nt, clrType, sqlType, sourceExpression) {
            switch (nt) {
                case SqlNodeType.Not:
                case SqlNodeType.Not2V:
                case SqlNodeType.Negate:
                case SqlNodeType.BitNot:
                case SqlNodeType.IsNull:
                case SqlNodeType.IsNotNull:
                case SqlNodeType.Count:
                case SqlNodeType.LongCount:
                case SqlNodeType.Max:
                case SqlNodeType.Min:
                case SqlNodeType.Sum:
                case SqlNodeType.Avg:
                case SqlNodeType.Stddev:
                case SqlNodeType.Convert:
                case SqlNodeType.ValueOf:
                case SqlNodeType.Treat:
                case SqlNodeType.OuterJoinedValue:
                case SqlNodeType.ClrLength:
                    break;
                default:
                    throw Error.UnexpectedNode(nt);
            }
            this.Operand = expr;
            this.method = method;
        }

        internal SqlExpression Operand {
            get { return this.operand; }
            set {
                if (value == null && (this.NodeType != SqlNodeType.Count && this.NodeType != SqlNodeType.LongCount))
                    throw Error.ArgumentNull("value");
                this.operand = value;
            }
        }

        internal MethodInfo Method {
            get { return this.method; }
        }
    }

    internal class SqlBinary : SqlSimpleTypeExpression {
        private SqlExpression left;
        private SqlExpression right;
        private MethodInfo method;

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
        internal SqlBinary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression left, SqlExpression right)
            : this(nt, clrType, sqlType, left, right, null) {
        }

        internal SqlBinary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression left, SqlExpression right, MethodInfo method)
            : base(nt, clrType, sqlType, right.SourceExpression) {
            switch (nt) {
                case SqlNodeType.Add:
                case SqlNodeType.Sub:
                case SqlNodeType.Mul:
                case SqlNodeType.Div:
                case SqlNodeType.Mod:
                case SqlNodeType.BitAnd:
                case SqlNodeType.BitOr:
                case SqlNodeType.BitXor:
                case SqlNodeType.And:
                case SqlNodeType.Or:
                case SqlNodeType.GE:
                case SqlNodeType.GT:
                case SqlNodeType.LE:
                case SqlNodeType.LT:
                case SqlNodeType.EQ:
                case SqlNodeType.NE:
                case SqlNodeType.EQ2V:
                case SqlNodeType.NE2V:
                case SqlNodeType.Concat:
                case SqlNodeType.Coalesce:
                    break;
                default:
                    throw Error.UnexpectedNode(nt);
            }
            this.Left = left;
            this.Right = right;
            this.method = method;
        }

        internal SqlExpression Left {
            get { return this.left; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.left = value;
            }
        }

        internal SqlExpression Right {
            get { return this.right; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.right = value;
            }
        }

        internal MethodInfo Method {
            get { return this.method; }
        }
    }

    internal class SqlBetween : SqlSimpleTypeExpression {
        SqlExpression expression;
        SqlExpression start;
        SqlExpression end;

        internal SqlBetween(Type clrType, ProviderType sqlType, SqlExpression expr, SqlExpression start, SqlExpression end, Expression source)
            : base(SqlNodeType.Between, clrType, sqlType, source) {
            this.expression = expr;
            this.start = start;
            this.end = end;
        }

        internal SqlExpression Expression {
            get { return this.expression; }
            set { this.expression = value; }
        }

        internal SqlExpression Start {
            get { return this.start; }
            set { this.start = value; }
        }

        internal SqlExpression End {
            get { return this.end; }
            set { this.end = value; }
        }
    }

    internal class SqlIn : SqlSimpleTypeExpression {
        private SqlExpression expression;
        private List<SqlExpression> values;

        internal SqlIn(Type clrType, ProviderType sqlType, SqlExpression expression, IEnumerable<SqlExpression> values, Expression sourceExpression)
            :base(SqlNodeType.In, clrType, sqlType, sourceExpression) {
            this.expression = expression;
            this.values = values != null ? new List<SqlExpression>(values) : new List<SqlExpression>(0);
        }

        internal SqlExpression Expression {
            get { return this.expression; }
            set {
                if (value == null) {
                    throw Error.ArgumentNull("value");
                }
                this.expression = value;
            }
        }
        internal List<SqlExpression> Values {
            get { return this.values; }
        }
    }

    internal class SqlLike : SqlSimpleTypeExpression {
        private SqlExpression expression;
        private SqlExpression pattern;
        private SqlExpression escape;

        internal SqlLike(Type clrType, ProviderType sqlType, SqlExpression expr, SqlExpression pattern, SqlExpression escape, Expression source)
            : base(SqlNodeType.Like, clrType, sqlType, source) {
            if (expr == null)
                throw Error.ArgumentNull("expr");
            if (pattern == null)
                throw Error.ArgumentNull("pattern");
            this.Expression = expr;
            this.Pattern = pattern;
            this.Escape = escape;
        }

        internal SqlExpression Expression {
            get { return this.expression; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (value.ClrType != typeof(string))
                    throw Error.ArgumentWrongType("value", "string", value.ClrType);
                this.expression = value;
            }
        }

        internal SqlExpression Pattern {
            get { return this.pattern; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (value.ClrType != typeof(string))
                    throw Error.ArgumentWrongType("value", "string", value.ClrType);
                this.pattern = value;
            }
        }

        internal SqlExpression Escape {
            get { return this.escape; }
            set {
                if (value != null && value.ClrType != typeof(string))
                    throw Error.ArgumentWrongType("value", "string", value.ClrType);
                this.escape = value;
            }
        }
    }

    internal class SqlWhen {
        private SqlExpression matchExpression;
        private SqlExpression valueExpression;

        internal SqlWhen(SqlExpression match, SqlExpression value) {
            // 'match' may be null when this when represents the ELSE condition.
            if (value == null)
                throw Error.ArgumentNull("value");
            this.Match = match;
            this.Value = value;
        }

        internal SqlExpression Match {
            get { return this.matchExpression; }
            set {
                if (this.matchExpression != null && value != null && this.matchExpression.ClrType != value.ClrType
                    // Exception: bool types, because predicates can have type bool or bool?
                    && !TypeSystem.GetNonNullableType(this.matchExpression.ClrType).Equals(typeof(bool))
                    && !TypeSystem.GetNonNullableType(value.ClrType).Equals(typeof(bool)))
                    throw Error.ArgumentWrongType("value", this.matchExpression.ClrType, value.ClrType);
                this.matchExpression = value;
            }
        }

        internal SqlExpression Value {
            get { return this.valueExpression; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (this.valueExpression != null && !this.valueExpression.ClrType.IsAssignableFrom(value.ClrType))
                    throw Error.ArgumentWrongType("value", this.valueExpression.ClrType, value.ClrType);
                this.valueExpression = value;
            }
        }
    }

    /*
     * Searched CASE function:
     * CASE
     * WHEN BooleanExpression THEN resultExpression 
     * [ ...n ] 
     * [ 
     * ELSE elseResultExpression 
     * ] 
     * END
     */
    internal class SqlSearchedCase : SqlExpression {
        private List<SqlWhen> whens;
        private SqlExpression @else;

        internal SqlSearchedCase(Type clrType, IEnumerable<SqlWhen> whens, SqlExpression @else, Expression sourceExpression)
            : base(SqlNodeType.SearchedCase, clrType, sourceExpression) {
            if (whens == null)
                throw Error.ArgumentNull("whens");
            this.whens = new List<SqlWhen>(whens);
            if (this.whens.Count == 0)
                throw Error.ArgumentOutOfRange("whens");
            this.Else = @else;
        }

        internal List<SqlWhen> Whens {
            get { return this.whens; }
        }

        internal SqlExpression Else {
            get { return this.@else; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (this.@else != null && [email protected](value.ClrType))
                    throw Error.ArgumentWrongType("value", [email protected], value.ClrType);
                this.@else = value;
            }
        }

        internal override ProviderType SqlType {
            get { return this.whens[0].Value.SqlType; }
        }
    }

    /*
     * Simple CASE function:
     * CASE inputExpression 
     * WHEN whenExpression THEN resultExpression 
     * [ ...n ] 
     * [ 
     * ELSE elseResultExpression 
     * ] 
     * END 
     */
    internal class SqlSimpleCase : SqlExpression {
        private SqlExpression expression;
        private List<SqlWhen> whens = new List<SqlWhen>();

        internal SqlSimpleCase(Type clrType, SqlExpression expr, IEnumerable<SqlWhen> whens, Expression sourceExpression)
            : base(SqlNodeType.SimpleCase, clrType, sourceExpression) {
            this.Expression = expr;
            if (whens == null)
                throw Error.ArgumentNull("whens");
            this.whens.AddRange(whens);
            if (this.whens.Count == 0)
                throw Error.ArgumentOutOfRange("whens");
        }

        internal SqlExpression Expression {
            get { return this.expression; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (this.expression != null && this.expression.ClrType != value.ClrType)
                    throw Error.ArgumentWrongType("value", this.expression.ClrType, value.ClrType);
                this.expression = value;
            }
        }

        internal List<SqlWhen> Whens {
            get { return this.whens; }
        }

        internal override ProviderType SqlType {
            get { return this.whens[0].Value.SqlType; }
        }
    }

    /// <summary>
    /// A case statement that must be evaluated on the client. For example, a case statement
    /// that contains values of LINK, Element, or Multi-set are not directly handleable by 
    /// SQL.
    /// 
    /// CASE inputExpression 
    /// WHEN whenExpression THEN resultExpression 
    /// [ ...n ] 
    /// END 
    /// </summary>
    internal class SqlClientCase : SqlExpression {
        private SqlExpression expression;
        private List<SqlClientWhen> whens = new List<SqlClientWhen>();

        internal SqlClientCase(Type clrType, SqlExpression expr, IEnumerable<SqlClientWhen> whens, Expression sourceExpression)
            : base(SqlNodeType.ClientCase, clrType, sourceExpression) {
            this.Expression = expr;
            if (whens == null)
                throw Error.ArgumentNull("whens");
            this.whens.AddRange(whens);
            if (this.whens.Count == 0)
                throw Error.ArgumentOutOfRange("whens");
        }

        internal SqlExpression Expression {
            get { return this.expression; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (this.expression != null && this.expression.ClrType != value.ClrType)
                    throw Error.ArgumentWrongType("value", this.expression.ClrType, value.ClrType);
                this.expression = value;
            }
        }

        internal List<SqlClientWhen> Whens {
            get { return this.whens; }
        }

        internal override ProviderType SqlType {
            get { return this.whens[0].Value.SqlType; }
        }
    }

    /// <summary>
    /// A single WHEN clause for ClientCase.
    /// </summary>
    internal class SqlClientWhen {
        private SqlExpression matchExpression;
        private SqlExpression matchValue;

        internal SqlClientWhen(SqlExpression match, SqlExpression value) {
            // 'match' may be null when this when represents the ELSE condition.
            if (value == null)
                throw Error.ArgumentNull("value");
            this.Match = match;
            this.Value = value;
        }

        internal SqlExpression Match {
            get { return this.matchExpression; }
            set {
                if (this.matchExpression != null && value != null && this.matchExpression.ClrType != value.ClrType)
                    throw Error.ArgumentWrongType("value", this.matchExpression.ClrType, value.ClrType);
                this.matchExpression = value;
            }
        }

        internal SqlExpression Value {
            get { return this.matchValue; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (this.matchValue != null && this.matchValue.ClrType != value.ClrType)
                    throw Error.ArgumentWrongType("value", this.matchValue.ClrType, value.ClrType);
                this.matchValue = value;
            }
        }
    }

    /// <summary>
    /// Represents the construction of an object in abstract 'super sql'.
    /// The type may be polymorphic. A discriminator field is used to determine 
    /// which type in a hierarchy should be instantiated.
    /// In the common degenerate case where the inheritance hierarchy is 1-deep 
    /// the discriminator will be a constant SqlValue and there will be one 
    /// type-case-when corresponding to that type.
    /// </summary>
    internal class SqlTypeCase : SqlExpression {
        private MetaType rowType;
        private SqlExpression discriminator;
        private List<SqlTypeCaseWhen> whens = new List<SqlTypeCaseWhen>();
        ProviderType sqlType;

        internal SqlTypeCase(Type clrType, ProviderType sqlType, MetaType rowType, SqlExpression discriminator, IEnumerable<SqlTypeCaseWhen> whens, Expression sourceExpression)
            : base(SqlNodeType.TypeCase, clrType, sourceExpression) {
            this.Discriminator = discriminator;
            if (whens == null)
                throw Error.ArgumentNull("whens");
            this.whens.AddRange(whens);
            if (this.whens.Count == 0)
                throw Error.ArgumentOutOfRange("whens");
            this.sqlType = sqlType;
            this.rowType = rowType;
        }

        internal SqlExpression Discriminator {
            get { return this.discriminator; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (this.discriminator != null && this.discriminator.ClrType != value.ClrType)
                    throw Error.ArgumentWrongType("value", this.discriminator.ClrType, value.ClrType);
                this.discriminator = value;
            }
        }

        internal List<SqlTypeCaseWhen> Whens {
            get { return this.whens; }
        }

        internal override ProviderType SqlType {
            get { return sqlType; }
        }

        internal MetaType RowType {
            get { return this.rowType; }
        }
    }

    /// <summary>
    /// Represents one choice of object instantiation type in a type case.
    /// When 'match' is the same as type case Discriminator then the corresponding
    /// type binding is the one used for instantiation.
    /// </summary>
    internal class SqlTypeCaseWhen {
        private SqlExpression match;
        private SqlExpression @new;

        internal SqlTypeCaseWhen(SqlExpression match, SqlExpression typeBinding) {
            this.Match = match;
            this.TypeBinding = typeBinding;
        }
        internal SqlExpression Match {
            get { return this.match; }
            set {
                if (this.match != null && value != null && this.match.ClrType != value.ClrType)
                    throw Error.ArgumentWrongType("value", this.match.ClrType, value.ClrType);
                this.match = value;
            }
        }
        internal SqlExpression TypeBinding {
            get { return this.@new; }
            set { this.@new = value; }
        }
    }

    internal class SqlValue : SqlSimpleTypeExpression {
        private object value;
        private bool isClient;

        internal SqlValue(Type clrType, ProviderType sqlType, object value, bool isClientSpecified, Expression sourceExpression)
            : base(SqlNodeType.Value, clrType, sqlType, sourceExpression) {
            this.value = value;
            this.isClient = isClientSpecified;
        }

        internal object Value {
            get { return this.value; }
        }

        internal bool IsClientSpecified {
            get { return this.isClient; }
        }
    }

    internal class SqlParameter : SqlSimpleTypeExpression {
        private string name;
        private System.Data.ParameterDirection direction;

        internal SqlParameter(Type clrType, ProviderType sqlType, string name, Expression sourceExpression)
            : base(SqlNodeType.Parameter, clrType, sqlType, sourceExpression) {
            if (name == null)
                throw Error.ArgumentNull("name");
            if (typeof(Type).IsAssignableFrom(clrType))
                throw Error.ArgumentWrongValue("clrType");
            this.name = name;
            this.direction = System.Data.ParameterDirection.Input;
        }

        internal string Name {
            get { return this.name; }
        }

        internal System.Data.ParameterDirection Direction {
            get { return this.direction; }
            set { this.direction = value; }
        }
    }

    internal class SqlVariable : SqlSimpleTypeExpression {
        private string name;

        internal SqlVariable(Type clrType, ProviderType sqlType, string name, Expression sourceExpression)
            : base(SqlNodeType.Variable, clrType, sqlType, sourceExpression) {
            if (name == null)
                throw Error.ArgumentNull("name");
            this.name = name;
        }

        internal string Name {
            get { return this.name; }
        }
    }

    internal class SqlMember : SqlSimpleTypeExpression {
        private SqlExpression expression;
        private MemberInfo member;

        internal SqlMember(Type clrType, ProviderType sqlType, SqlExpression expr, MemberInfo member)
            : base(SqlNodeType.Member, clrType, sqlType, expr.SourceExpression) {
            this.member = member;
            this.Expression = expr;
        }

        internal MemberInfo Member {
            get { return this.member; }
        }

        internal SqlExpression Expression {
            get {
                return this.expression;
            }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (!this.member.ReflectedType.IsAssignableFrom(value.ClrType) &&
                    !value.ClrType.IsAssignableFrom(this.member.ReflectedType))
                    throw Error.MemberAccessIllegal(this.member, this.member.ReflectedType, value.ClrType);
                this.expression = value;
            }
        }
    }

    internal class SqlColumn : SqlExpression {
        private SqlAlias alias;
        private string name;
        private int ordinal;
        private MetaDataMember member;
        private SqlExpression expression;
        private ProviderType sqlType;

        internal SqlColumn(Type clrType, ProviderType sqlType, string name, MetaDataMember member, SqlExpression expr, Expression sourceExpression)
            : base(SqlNodeType.Column, clrType, sourceExpression) {
            if (typeof(Type).IsAssignableFrom(clrType))
                throw Error.ArgumentWrongValue("clrType");
            this.Name = name;
            this.member = member;
            this.Expression = expr;
            this.Ordinal = -1;
            if (sqlType == null)
                throw Error.ArgumentNull("sqlType");
            this.sqlType = sqlType;
            System.Diagnostics.Debug.Assert(sqlType.CanBeColumn);
        }

        internal SqlColumn(string name, SqlExpression expr)
            : this(expr.ClrType, expr.SqlType, name, null, expr, expr.SourceExpression) {
            System.Diagnostics.Debug.Assert(expr != null);
        }

        internal SqlAlias Alias {
            get { return this.alias; }
            set { this.alias = value; }
        }

        internal string Name {
            get { return this.name; }
            set { this.name = value; }
        }

        internal int Ordinal {
            get { return this.ordinal; }
            set { this.ordinal = value; }
        }

        internal MetaDataMember MetaMember {
            get { return this.member; }
        }

        /// <summary>
        /// Set the column's Expression. This can change the type of the column.
        /// </summary>
        internal SqlExpression Expression {
            get {
                return this.expression;
            }
            set {
                if (value != null) {
                    if (!this.ClrType.IsAssignableFrom(value.ClrType))
                        throw Error.ArgumentWrongType("value", this.ClrType, value.ClrType);
                    SqlColumnRef cref = value as SqlColumnRef;
                    if (cref != null && cref.Column == this)
                        throw Error.ColumnCannotReferToItself();
                }
                this.expression = value;
            }
        }

        internal override ProviderType SqlType {
            get {
                if (this.expression != null)
                    return this.expression.SqlType;
                return this.sqlType;
            }
        }
    }

    internal class SqlColumnRef : SqlExpression {
        private SqlColumn column;
        internal SqlColumnRef(SqlColumn col)
            : base(SqlNodeType.ColumnRef, col.ClrType, col.SourceExpression) {
            this.column = col;
        }

        internal SqlColumn Column {
            get { return this.column; }
        }

        internal override ProviderType SqlType {
            get { return this.column.SqlType; }
        }

        public override bool Equals(object obj) {
            SqlColumnRef cref = obj as SqlColumnRef;
            return cref != null && cref.Column == this.column;
        }

        public override int GetHashCode() {
            return this.column.GetHashCode();
        }

        internal SqlColumn GetRootColumn() {
            SqlColumn c = this.column;
            while (c.Expression != null && c.Expression.NodeType == SqlNodeType.ColumnRef) {
                c = ((SqlColumnRef)c.Expression).Column;
            }
            return c;
        }
    }

    internal class SqlRow : SqlNode {
        private List<SqlColumn> columns;

        internal SqlRow(Expression sourceExpression)
            : base(SqlNodeType.Row, sourceExpression) {
            this.columns = new List<SqlColumn>();
        }

        internal List<SqlColumn> Columns {
            get { return this.columns; }
        }

        internal SqlColumn Find(string name) {
            foreach (SqlColumn c in this.columns) {
                if (name == c.Name)
                    return c;
            }
            return null;
        }
    }

    internal class SqlMemberAssign : SqlNode {
        private MemberInfo member;
        private SqlExpression expression;

        internal SqlMemberAssign(MemberInfo member, SqlExpression expr)
            : base(SqlNodeType.MemberAssign, expr.SourceExpression) {
            if (member == null)
                throw Error.ArgumentNull("member");
            this.member = member;
            this.Expression = expr;
        }

        internal MemberInfo Member {
            get { return this.member; }
        }

        internal SqlExpression Expression {
            get { return this.expression; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.expression = value;
            }
        }
    }

    internal class SqlGrouping : SqlSimpleTypeExpression {
        private SqlExpression key;
        private SqlExpression group;

        internal SqlGrouping(Type clrType, ProviderType sqlType, SqlExpression key, SqlExpression group, Expression sourceExpression)
            : base(SqlNodeType.Grouping, clrType, sqlType, sourceExpression) {
            if (key == null) throw Error.ArgumentNull("key");
            if (group == null) throw Error.ArgumentNull("group");
            this.key = key;
            this.group = group;
        }

        internal SqlExpression Key {
            get { return this.key; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (!this.key.ClrType.IsAssignableFrom(value.ClrType)
                    && !value.ClrType.IsAssignableFrom(this.key.ClrType))
                    throw Error.ArgumentWrongType("value", this.key.ClrType, value.ClrType);
                this.key = value;
            }
        }

        internal SqlExpression Group {
            get { return this.group; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (value.ClrType != this.group.ClrType)
                    throw Error.ArgumentWrongType("value", this.group.ClrType, value.ClrType);
                this.group = value;
            }
        }
    }

    internal class SqlNew : SqlSimpleTypeExpression {
        private MetaType metaType;
        private ConstructorInfo constructor;
        private List<SqlExpression> args;
        private List<MemberInfo> argMembers;
        private List<SqlMemberAssign> members;

        internal SqlNew(MetaType metaType, ProviderType sqlType, ConstructorInfo cons, IEnumerable<SqlExpression> args, IEnumerable<MemberInfo> argMembers, IEnumerable<SqlMemberAssign> members, Expression sourceExpression)
            : base(SqlNodeType.New, metaType.Type, sqlType, sourceExpression) {
            this.metaType = metaType;
            
            if (cons == null && metaType.Type.IsClass) { // structs do not need to have a constructor
                throw Error.ArgumentNull("cons");
            }
            this.constructor = cons;
            this.args = new List<SqlExpression>();
            this.argMembers = new List<MemberInfo>();
            this.members = new List<SqlMemberAssign>();
            if (args != null) {
                this.args.AddRange(args);
            }
            if (argMembers != null) {
                this.argMembers.AddRange(argMembers);
            }
            if (members != null) {
                this.members.AddRange(members);
            }
        }

        internal MetaType MetaType {
            get { return this.metaType; }
        }

        internal ConstructorInfo Constructor {
            get { return this.constructor; }
        }

        internal List<SqlExpression> Args {
            get { return this.args; }
        }

        internal List<MemberInfo> ArgMembers {
            get { return this.argMembers; }
        }

        internal List<SqlMemberAssign> Members {
            get { return this.members; }
        }

        internal SqlExpression Find(MemberInfo mi) {
            for (int i = 0, n = this.argMembers.Count; i < n; i++) {
                MemberInfo argmi = this.argMembers[i];
                if (argmi.Name == mi.Name) {
                    return this.args[i];
                }
            }

            foreach (SqlMemberAssign ma in this.Members) {
                if (ma.Member.Name == mi.Name) {
                    return ma.Expression;
                }
            }

            return null;
        }
    }

    internal class SqlMethodCall : SqlSimpleTypeExpression {
        private MethodInfo method;
        private SqlExpression obj;
        private List<SqlExpression> arguments;

        internal SqlMethodCall(Type clrType, ProviderType sqlType, MethodInfo method, SqlExpression obj, IEnumerable<SqlExpression> args, Expression sourceExpression)
            : base(SqlNodeType.MethodCall, clrType, sqlType, sourceExpression) {
            if (method == null)
                throw Error.ArgumentNull("method");
            this.method = method;
            this.Object = obj;
            this.arguments = new List<SqlExpression>();
            if (args != null)
                this.arguments.AddRange(args);
        }

        internal MethodInfo Method {
            get { return this.method; }
        }

        internal SqlExpression Object {
            get { return this.obj; }
            set {
                if (value == null && !this.method.IsStatic)
                    throw Error.ArgumentNull("value");
                if (value != null && !this.method.DeclaringType.IsAssignableFrom(value.ClrType))
                    throw Error.ArgumentWrongType("value", this.method.DeclaringType, value.ClrType);
                this.obj = value;
            }
        }

        internal List<SqlExpression> Arguments {
            get { return this.arguments; }
        }
    }

    internal class SqlIncludeScope : SqlNode {
        SqlNode child;
        internal SqlIncludeScope(SqlNode child, Expression sourceExpression) 
            : base(SqlNodeType.IncludeScope, sourceExpression) { 
            this.child = child;
        }
        internal SqlNode Child {
            get {return this.child;}
            set {this.child = value;}
        }
    }

    internal class SqlClientArray : SqlSimpleTypeExpression {
        private List<SqlExpression> expressions;

        internal SqlClientArray(Type clrType, ProviderType sqlType, SqlExpression[ ] exprs, Expression sourceExpression)
            : base(SqlNodeType.ClientArray, clrType, sqlType, sourceExpression) {
            this.expressions = new List<SqlExpression>();
            if (exprs != null)
                this.Expressions.AddRange(exprs);
        }

        internal List<SqlExpression> Expressions {
            get { return this.expressions; }
        }
    }

    internal class SqlLink : SqlSimpleTypeExpression {
        private MetaType rowType;
        private SqlExpression expression;
        private MetaDataMember member;
        private List<SqlExpression> keyExpressions;
        private SqlExpression expansion;
        private object id;

        internal SqlLink(object id, MetaType rowType, Type clrType, ProviderType sqlType, SqlExpression expression, MetaDataMember member, IEnumerable<SqlExpression> keyExpressions, SqlExpression expansion, Expression sourceExpression)
            : base(SqlNodeType.Link, clrType, sqlType, sourceExpression) {
            this.id = id;
            this.rowType = rowType;
            this.expansion = expansion;
            this.expression = expression;
            this.member = member;
            this.keyExpressions = new List<SqlExpression>();
            if (keyExpressions != null)
                this.keyExpressions.AddRange(keyExpressions);
        }

        internal MetaType RowType {
            get { return this.rowType; }
        }

        internal SqlExpression Expansion {
            get { return this.expansion; }
            set { this.expansion = value; }
        }


        internal SqlExpression Expression {
            get { return this.expression; }
            set { this.expression = value; }
        }

        internal MetaDataMember Member {
            get { return this.member; }
        }

        internal List<SqlExpression> KeyExpressions {
            get { return this.keyExpressions; }
        }

        internal object Id {
            get { return this.id; }
        }
    }

    internal class SqlExprSet : SqlExpression {
        private List<SqlExpression> expressions;

        internal SqlExprSet(Type clrType, IEnumerable <SqlExpression> exprs, Expression sourceExpression)
            : base(SqlNodeType.ExprSet, clrType, sourceExpression) {
            this.expressions = new List<SqlExpression>(exprs);
        }

        internal List<SqlExpression> Expressions {
            get { return this.expressions; }
        }

        /// <summary>
        /// Get the first non-set expression of the set by drilling
        /// down the left expressions.
        /// </summary>
        internal SqlExpression GetFirstExpression() {
            SqlExpression expr = expressions[0];
            while (expr is SqlExprSet) {
                expr = ((SqlExprSet)expr).Expressions[0];
            }
            return expr;
        }

        internal override ProviderType SqlType {
            get { return this.expressions[0].SqlType; }
        }
    }

    internal class SqlSubSelect : SqlSimpleTypeExpression {
        private SqlSelect select;

        internal SqlSubSelect(SqlNodeType nt , Type clrType, ProviderType sqlType , SqlSelect select)
            : base(nt, clrType, sqlType, select.SourceExpression) {
            switch (nt) {
                case SqlNodeType.Multiset:
                case SqlNodeType.ScalarSubSelect:
                case SqlNodeType.Element:
                case SqlNodeType.Exists:
                    break;
                default:
                    throw Error.UnexpectedNode(nt);
            }
            this.Select = select;
        }

        internal SqlSelect Select {
            get { return this.select; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.select = value;
            }
        }
    }

    internal class SqlClientQuery : SqlSimpleTypeExpression {
        private SqlSubSelect query;
        private List<SqlExpression> arguments;
        private List<SqlParameter> parameters;
        int ordinal;

        internal SqlClientQuery(SqlSubSelect subquery)
            : base(SqlNodeType.ClientQuery, subquery.ClrType, subquery.SqlType, subquery.SourceExpression) {
            this.query = subquery;
            this.arguments = new List<SqlExpression>();
            this.parameters = new List<SqlParameter>();
        }

        internal SqlSubSelect Query {
            get { return this.query; }
            set {
                if (value == null || (this.query != null && this.query.ClrType != value.ClrType))
                    throw Error.ArgumentWrongType(value, this.query.ClrType, value.ClrType);
                this.query = value;
            }
        }

        internal List<SqlExpression> Arguments {
            get { return this.arguments; }
        }

        internal List<SqlParameter> Parameters {
            get { return this.parameters; }
        }

        internal int Ordinal {
            get { return this.ordinal; }
            set { this.ordinal = value; }
        }
    }

    internal class SqlJoinedCollection : SqlSimpleTypeExpression {
        private SqlExpression expression;
        private SqlExpression count;

        internal SqlJoinedCollection(Type clrType, ProviderType sqlType, SqlExpression expression, SqlExpression count, Expression sourceExpression)
            : base(SqlNodeType.JoinedCollection, clrType, sqlType, sourceExpression) {
            this.expression = expression;
            this.count = count;
        }

        internal SqlExpression Expression {
            get { return this.expression; }
            set {
                if (value == null || this.expression != null && this.expression.ClrType != value.ClrType)
                    throw Error.ArgumentWrongType(value, this.expression.ClrType, value.ClrType);
                this.expression = value;
            }
        }

        internal SqlExpression Count {
            get { return this.count; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (value.ClrType != typeof(int))
                    throw Error.ArgumentWrongType(value, typeof(int), value.ClrType);
                this.count = value;
            }
        }
    }

    internal class SqlUpdate : SqlStatement {
        private SqlSelect select;
        private List<SqlAssign> assignments;

        internal SqlUpdate(SqlSelect select, IEnumerable<SqlAssign> assignments, Expression sourceExpression)
            : base(SqlNodeType.Update, sourceExpression) {
            this.Select = select;
            this.assignments = new List<SqlAssign>(assignments);
        }

        internal SqlSelect Select {
            get { return this.select; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.select = value;
            }
        }

        internal List<SqlAssign> Assignments {
            get { return this.assignments; }
        }
    }

    internal class SqlInsert : SqlStatement {
        private SqlTable table;
        private SqlRow row;
        private SqlExpression expression;
        private SqlColumn outputKey;
        private bool outputToLocal;

        internal SqlInsert(SqlTable table, SqlExpression expr, Expression sourceExpression)
            : base(SqlNodeType.Insert, sourceExpression) {
            this.Table = table;
            this.Expression = expr;
            this.Row = new SqlRow(sourceExpression);
        }

        internal SqlTable Table {
            get { return this.table; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("null");
                this.table = value;
            }
        }

        internal SqlRow Row {
            get { return this.row; }
            set { this.row = value; }
        }

        internal SqlExpression Expression {
            get { return this.expression; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("null");
                if (!this.table.RowType.Type.IsAssignableFrom(value.ClrType))
                    throw Error.ArgumentWrongType("value", this.table.RowType, value.ClrType);
                this.expression = value;
            }
        }

        internal SqlColumn OutputKey {
            get { return this.outputKey; }
            set { this.outputKey = value; }
        }

        internal bool OutputToLocal {
            get { return this.outputToLocal; }
            set { this.outputToLocal = value; }
        }
    }

    internal class SqlDelete : SqlStatement {
        private SqlSelect select;

        internal SqlDelete(SqlSelect select, Expression sourceExpression)
            : base(SqlNodeType.Delete, sourceExpression) {
            this.Select = select;
        }

        internal SqlSelect Select {
            get { return this.select; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.select = value;
            }
        }
    }

    internal class SqlBlock : SqlStatement {
        private List<SqlStatement> statements;

        internal SqlBlock(Expression sourceExpression)
            : base(SqlNodeType.Block, sourceExpression) {
            this.statements = new List<SqlStatement>();
        }

        internal List<SqlStatement> Statements {
            get { return this.statements; }
        }
    }

    internal class SqlAssign : SqlStatement {
        private SqlExpression leftValue;
        private SqlExpression rightValue;

        internal SqlAssign(SqlExpression lValue, SqlExpression rValue, Expression sourceExpression)
            : base(SqlNodeType.Assign, sourceExpression) {
            this.LValue = lValue;
            this.RValue = rValue;
        }

        internal SqlExpression LValue {
            get { return this.leftValue; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (this.rightValue != null && !value.ClrType.IsAssignableFrom(this.rightValue.ClrType))
                    throw Error.ArgumentWrongType("value", this.rightValue.ClrType, value.ClrType);
                this.leftValue = value;
            }
        }

        internal SqlExpression RValue {
            get { return this.rightValue; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (this.leftValue != null && !this.leftValue.ClrType.IsAssignableFrom(value.ClrType))
                    throw Error.ArgumentWrongType("value", this.leftValue.ClrType, value.ClrType);
                this.rightValue = value;
            }
        }
    }

    internal class SqlDoNotVisitExpression : SqlExpression {
        private SqlExpression expression;

        internal SqlDoNotVisitExpression(SqlExpression expr)
            : base(SqlNodeType.DoNotVisit, expr.ClrType, expr.SourceExpression) {
            if (expr == null)
                throw Error.ArgumentNull("expr");
            this.expression = expr;
        }

        internal SqlExpression Expression {
            get { return this.expression; }
        }

        internal override ProviderType SqlType {
            get { return this.expression.SqlType; }
        }
    }

    internal class SqlOptionalValue : SqlSimpleTypeExpression {
        private SqlExpression hasValue;
        private SqlExpression expressionValue;

        internal SqlOptionalValue( SqlExpression hasValue, SqlExpression value)
            : base(SqlNodeType.OptionalValue, value.ClrType, value.SqlType, value.SourceExpression) {
            this.HasValue = hasValue;
            this.Value = value;
        }

        internal SqlExpression HasValue {
            get { return this.hasValue; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                this.hasValue = value;
            }
        }

        internal SqlExpression Value {
            get { return this.expressionValue; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (value.ClrType != this.ClrType)
                    throw Error.ArgumentWrongType("value", this.ClrType, value.ClrType);
                this.expressionValue = value;
            }
        }
    }

    internal class SqlFunctionCall : SqlSimpleTypeExpression {
        private string name;
        private List<SqlExpression> arguments;

        internal SqlFunctionCall(Type clrType, ProviderType sqlType, string name, IEnumerable <SqlExpression > args , Expression source)
            : this(SqlNodeType.FunctionCall, clrType , sqlType, name, args, source) {
        }

        internal SqlFunctionCall(SqlNodeType nodeType, Type clrType, ProviderType sqlType, string name , IEnumerable <SqlExpression> args , Expression source)
            : base(nodeType, clrType, sqlType, source) {
            this.name = name;
            this.arguments = new List<SqlExpression>(args);
        }

        internal string Name {
            get { return this.name; }
        }

        internal List<SqlExpression> Arguments {
            get { return this.arguments; }
        }
    }

    /// <summary>
    /// This class is used to represent a table value function.  It inherits normal function
    /// call functionality, and adds TVF specific members.
    /// </summary>
    internal class SqlTableValuedFunctionCall : SqlFunctionCall {
        private MetaType rowType;
        private List<SqlColumn> columns;

        internal SqlTableValuedFunctionCall(MetaType rowType, Type clrType, ProviderType sqlType, string name, IEnumerable <SqlExpression > args , Expression source)
            : base(SqlNodeType.TableValuedFunctionCall, clrType , sqlType, name, args, source) {
            this.rowType = rowType;
            this.columns = new List<SqlColumn>();
        }

        internal MetaType RowType {
            get { return this.rowType; }
        }

        internal List<SqlColumn> Columns {
            get { return this.columns; }
        }

        internal SqlColumn Find(string name) {
            foreach (SqlColumn c in this.Columns) {
                if (c.Name == name)
                    return c;
            }
            return null;
        }

    }

    internal class SqlSharedExpression : SqlExpression {
        private SqlExpression expr;

        internal SqlSharedExpression(SqlExpression expr)
          : base(SqlNodeType.SharedExpression, expr.ClrType, expr.SourceExpression) {
            this.expr = expr;
        }

        internal SqlExpression Expression {
            get { return this.expr; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (!this.ClrType.IsAssignableFrom(value.ClrType)
                    && !value.ClrType.IsAssignableFrom(this.ClrType))
                    throw Error.ArgumentWrongType("value", this.ClrType, value.ClrType);
                this.expr = value;
            }
        }

        internal override ProviderType SqlType {
            get { return this.expr.SqlType; }
        }
    }

    internal class SqlSharedExpressionRef : SqlExpression {
        private SqlSharedExpression expr;

        internal SqlSharedExpressionRef(SqlSharedExpression expr)
            : base(SqlNodeType.SharedExpressionRef, expr.ClrType, expr.SourceExpression) {
            this.expr = expr;
        }

        internal SqlSharedExpression SharedExpression {
            get { return this.expr; }
        }

        internal override ProviderType SqlType {
            get { return this.expr.SqlType; }
        }
    }

    internal class SqlSimpleExpression : SqlExpression {
        private SqlExpression expr;

        internal SqlSimpleExpression(SqlExpression expr)
            : base(SqlNodeType.SimpleExpression, expr.ClrType, expr.SourceExpression) {
            this.expr = expr;
        }

        internal SqlExpression Expression {
            get { return this.expr; }
            set {
                if (value == null)
                    throw Error.ArgumentNull("value");
                if (!TypeSystem.GetNonNullableType(this.ClrType).IsAssignableFrom(TypeSystem.GetNonNullableType(value.ClrType)))
                    throw Error.ArgumentWrongType("value", this.ClrType, value.ClrType);
                this.expr = value;
            }
        }

        internal override ProviderType SqlType {
            get { return this.expr.SqlType; }
        }
    }

    internal class SqlClientParameter : SqlSimpleTypeExpression {
        // Expression<Func<object[], T>>
        LambdaExpression accessor;
        internal SqlClientParameter(Type clrType, ProviderType sqlType, LambdaExpression accessor, Expression sourceExpression):
            base(SqlNodeType.ClientParameter, clrType, sqlType, sourceExpression) {
            this.accessor = accessor;
        }
        internal LambdaExpression Accessor {
            get { return this.accessor; }
        }
    }
}