RelOps.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Query / InternalTrees / RelOps.cs / 1305376 / RelOps.cs

                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner  [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

using System; 
using System.Collections.Generic;
using System.Data.Metadata.Edm;
using System.Diagnostics;
using System.Globalization; 
using System.Text;
 
namespace System.Data.Query.InternalTrees 
{
    internal abstract class ScanTableBaseOp : RelOp 
    {
        #region private state
        private Table m_table;
        #endregion 

        #region constructors 
        protected ScanTableBaseOp(OpType opType, Table table) 
            : base(opType)
        { 
            m_table = table;
        }
        protected ScanTableBaseOp(OpType opType)
            : base(opType) 
        { }
        #endregion 
 
        #region public methods
        ///  
        /// Get the table instance produced by this Op
        /// 
        internal Table Table { get { return m_table; } }
        #endregion 
    }
 
    ///  
    /// Scans a table
    ///  
    internal sealed class ScanTableOp : ScanTableBaseOp
    {
        #region constructors
        ///  
        /// Scan constructor
        ///  
        ///  
        internal ScanTableOp(Table table)
            : base(OpType.ScanTable, table) 
        {
        }

        private ScanTableOp() : base(OpType.ScanTable) { } 
#endregion
 
        #region public methods 
        /// 
        /// Only to be used for pattern matches 
        /// 
        internal static readonly ScanTableOp Pattern = new ScanTableOp();

        ///  
        /// No children
        ///  
        internal override int Arity {get {return 0;} } 

        ///  
        /// Visitor pattern method
        /// 
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op 
        [DebuggerNonUserCode]
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 
 
        /// 
        /// Visitor pattern method for visitors with a return value 
        /// 
        /// The visitor
        /// The node in question
        /// An instance of TResultType 
        [DebuggerNonUserCode]
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); } 
#endregion 
    }
 
    /// 
    /// Scans a view - very similar to a ScanTable
    /// 
    internal sealed class ScanViewOp : ScanTableBaseOp 
    {
        #region constructors 
        ///  
        /// Scan constructor
        ///  
        /// 
        internal ScanViewOp(Table table)
            : base(OpType.ScanView, table)
        { 
        }
        private ScanViewOp() : base(OpType.ScanView) { } 
#endregion 

        #region public methods 
        /// 
        /// Only to be used for pattern matches
        /// 
        internal static readonly ScanViewOp Pattern = new ScanViewOp(); 

        ///  
        /// Exactly 1 child 
        /// 
        internal override int Arity { get { return 1; } } 

        /// 
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op 
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
 
        /// 
        /// Visitor pattern method for visitors with a return value
        /// 
        /// The visitor 
        /// The node in question
        /// An instance of TResultType 
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion 
    }

    /// 
    /// Scans a virtual extent (ie) a transient collection 
    /// 
    internal sealed class UnnestOp : RelOp 
    { 
        #region private state
        private Table m_table; 
        private Var m_var;
        #endregion

        #region constructors 
        internal UnnestOp(Var v, Table t) : this()
        { 
            m_var = v; 
            m_table = t;
        } 
        private UnnestOp()
            : base(OpType.Unnest)
        {
        } 
#endregion
 
        #region publics 
        internal static readonly UnnestOp Pattern = new UnnestOp();
 
        /// 
        /// The (collection-typed) Var that's being unnested
        /// 
        internal Var Var { get { return m_var; } } 

        ///  
        /// The table instance produced by this Op 
        /// 
        internal Table Table { get { return m_table; } } 

        /// 
        /// Exactly 1 child
        ///  
        internal override int Arity { get { return 1; } }
 
        ///  
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op
        [DebuggerNonUserCode]
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 

        ///  
        /// Visitor pattern method for visitors with a return value 
        /// 
        /// The visitor 
        /// The node in question
        /// An instance of TResultType
        [DebuggerNonUserCode]
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); } 
        #endregion
    } 
 
    /// 
    /// Base class for all Join operations 
    /// 
    internal abstract class JoinBaseOp : RelOp
    {
        #region constructors 
        internal JoinBaseOp(OpType opType) : base(opType) { }
        #endregion 
 
        #region public surface
        ///  
        /// 3 children - left, right, pred
        /// 
        internal override int Arity { get { return 3; } }
        #endregion 
    }
 
    ///  
    /// A CrossJoin (n-way)
    ///  
    internal sealed class CrossJoinOp : JoinBaseOp
    {
        #region constructors
        private CrossJoinOp() : base(OpType.CrossJoin) { } 
        #endregion
 
        #region public methods 
        /// 
        /// Singleton instance 
        /// 
        internal static readonly CrossJoinOp Instance = new CrossJoinOp();
        internal static readonly CrossJoinOp Pattern = CrossJoinOp.Instance;
 
        /// 
        /// varying number of children (but usually greater than 1) 
        ///  
        internal override int Arity { get { return ArityVarying; } }
 
        /// 
        /// Visitor pattern method
        /// 
        /// The BasicOpVisitor that is visiting this Op 
        /// The Node that references this Op
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 

        ///  
        /// Visitor pattern method for visitors with a return value
        /// 
        /// The visitor
        /// The node in question 
        /// An instance of TResultType
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); } 
        #endregion
    } 

    /// 
    /// An InnerJoin
    ///  
    internal sealed class InnerJoinOp : JoinBaseOp
    { 
        #region constructors 
        private InnerJoinOp() : base(OpType.InnerJoin) { }
        #endregion 

        #region public methods
        internal static readonly InnerJoinOp Instance = new InnerJoinOp();
        internal static readonly InnerJoinOp Pattern = InnerJoinOp.Instance; 

        ///  
        /// Visitor pattern method 
        /// 
        /// The BasicOpVisitor that is visiting this Op 
        /// The Node that references this Op
        [DebuggerNonUserCode]
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
 
        /// 
        /// Visitor pattern method for visitors with a return value 
        ///  
        /// The visitor
        /// The node in question 
        /// An instance of TResultType
        [DebuggerNonUserCode]
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion 
    }
 
    ///  
    /// A LeftOuterJoin
    ///  
    internal sealed class LeftOuterJoinOp : JoinBaseOp
    {
        #region constructors
        private LeftOuterJoinOp() : base(OpType.LeftOuterJoin) { } 
        #endregion
 
        #region public methods 
        internal static readonly LeftOuterJoinOp Instance = new LeftOuterJoinOp();
        internal static readonly LeftOuterJoinOp Pattern = LeftOuterJoinOp.Instance; 

        /// 
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op 
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
 
        /// 
        /// Visitor pattern method for visitors with a return value
        /// 
        /// The visitor 
        /// The node in question
        /// An instance of TResultType 
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion 
    }

    /// 
    /// A FullOuterJoin 
    /// 
    internal sealed class FullOuterJoinOp : JoinBaseOp 
    { 
        #region private constructors
        private FullOuterJoinOp() : base(OpType.FullOuterJoin) { } 
        #endregion

        #region public methods
        internal static readonly FullOuterJoinOp Instance = new FullOuterJoinOp(); 
        internal static readonly FullOuterJoinOp Pattern = FullOuterJoinOp.Instance;
 
        ///  
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op
        [DebuggerNonUserCode]
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 

        ///  
        /// Visitor pattern method for visitors with a return value 
        /// 
        /// The visitor 
        /// The node in question
        /// An instance of TResultType
        [DebuggerNonUserCode]
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); } 
        #endregion
    } 
 
    /// 
    /// Base class for all Apply Ops 
    /// 
    internal abstract class ApplyBaseOp : RelOp
    {
        #region constructors 
        internal ApplyBaseOp(OpType opType) : base(opType) { }
        #endregion 
 
        #region public surface
        ///  
        /// 2 children - left, right
        /// 
        internal override int Arity { get { return 2; } }
        #endregion 
    }
 
    ///  
    /// CrossApply
    ///  
    internal sealed class CrossApplyOp : ApplyBaseOp
    {
        #region constructors
        private CrossApplyOp() : base(OpType.CrossApply) { } 
        #endregion
 
        #region public methods 
        internal static readonly CrossApplyOp Instance = new CrossApplyOp();
        internal static readonly CrossApplyOp Pattern = CrossApplyOp.Instance; 

        /// 
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op 
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
 
        /// 
        /// Visitor pattern method for visitors with a return value
        /// 
        /// The visitor 
        /// The node in question
        /// An instance of TResultType 
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion 
    }

    /// 
    /// OuterApply 
    /// 
    internal sealed class OuterApplyOp : ApplyBaseOp 
    { 
        #region constructors
        private OuterApplyOp() : base(OpType.OuterApply) { } 
        #endregion

        #region public methods
        internal static readonly OuterApplyOp Instance = new OuterApplyOp(); 
        internal static readonly OuterApplyOp Pattern = OuterApplyOp.Instance;
 
        ///  
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op
        [DebuggerNonUserCode]
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 

        ///  
        /// Visitor pattern method for visitors with a return value 
        /// 
        /// The visitor 
        /// The node in question
        /// An instance of TResultType
        [DebuggerNonUserCode]
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); } 
        #endregion
    } 
 
    /// 
    /// FilterOp 
    /// 
    internal sealed class FilterOp : RelOp
    {
        #region constructors 
        private FilterOp() : base(OpType.Filter) { }
        #endregion 
 
        #region public methods
        internal static readonly FilterOp Instance = new FilterOp(); 
        internal static readonly FilterOp Pattern = FilterOp.Instance;

        /// 
        /// 2 children - input, pred 
        /// 
        internal override int Arity { get { return 2; } } 
 
        /// 
        /// Visitor pattern method 
        /// 
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
 
        ///  
        /// Visitor pattern method for visitors with a return value
        ///  
        /// The visitor
        /// The node in question
        /// An instance of TResultType
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion 
    } 

    ///  
    /// ProjectOp
    /// 
    internal sealed class ProjectOp : RelOp
    { 
        #region private state
        private VarVec m_vars; 
        #endregion 

        #region constructors 
        private ProjectOp()
            : base(OpType.Project)
        { }
        internal ProjectOp(VarVec vars) : this() 
        {
            Debug.Assert(null != vars, "null vars?"); 
            Debug.Assert(!vars.IsEmpty, "empty varlist?"); 
            m_vars = vars;
        } 
        #endregion

        #region public methods
        internal static readonly ProjectOp Pattern = new ProjectOp(); 

        ///  
        /// 2 children - input, projections (VarDefList) 
        /// 
        internal override int Arity { get { return 2; } } 

        /// 
        /// The Vars projected by this Op
        ///  
        internal VarVec Outputs { get { return m_vars; } }
 
        ///  
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op
        [DebuggerNonUserCode]
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 

        ///  
        /// Visitor pattern method for visitors with a return value 
        /// 
        /// The visitor 
        /// The node in question
        /// An instance of TResultType
        [DebuggerNonUserCode]
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); } 
        #endregion
    } 
 
    /// 
    /// A Sortkey 
    /// 
    internal class SortKey
    {
        #region private state 
        private Var m_var;
        private bool m_asc; 
        private string m_collation; 
        #endregion
 
        #region constructors
        internal SortKey(Var v, bool asc, string collation)
        {
            m_var = v; 
            m_asc = asc;
            m_collation = collation; 
        } 
        #endregion
 
        #region public methods
        /// 
        /// The Var being sorted
        ///  
        internal Var Var
        { 
            get { return m_var; } 
            set { m_var = value; }
        } 

        /// 
        /// Is this a sort asc, or a sort desc
        ///  
        internal bool AscendingSort { get { return m_asc; } }
 
        ///  
        /// An optional collation (only for string types)
        ///  
        internal string Collation { get { return m_collation; } }
        #endregion
    }
 
    /// 
    /// Base type for SortOp and ConstrainedSortOp 
    ///  
    internal abstract class SortBaseOp : RelOp
    { 
        #region private state
        private List m_keys;
        #endregion
 
        #region Constructors
        // Pattern constructor 
        internal SortBaseOp(OpType opType) 
            : base(opType)
        { 
            Debug.Assert(opType == OpType.Sort || opType == OpType.ConstrainedSort, "SortBaseOp OpType must be Sort or ConstrainedSort");
        }

        internal SortBaseOp(OpType opType, List sortKeys) 
            : this(opType)
        { 
            m_keys = sortKeys; 
        }
 
        #endregion

        /// 
        /// Sort keys 
        /// 
        internal List Keys { get { return m_keys; } } 
    } 

    ///  
    /// A SortOp
    /// 
    internal sealed class SortOp : SortBaseOp
    { 
        #region constructors
        private SortOp() : base(OpType.Sort) { } 
 
        internal SortOp(List sortKeys) : base(OpType.Sort, sortKeys) {}
        #endregion 

        #region public methods
        internal static readonly SortOp Pattern = new SortOp();
 
        /// 
        /// 1 child - the input, SortOp must not contain local VarDefs 
        ///  
        internal override int Arity { get { return 1; } }
 
        /// 
        /// Visitor pattern method
        /// 
        /// The BasicOpVisitor that is visiting this Op 
        /// The Node that references this Op
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 

        ///  
        /// Visitor pattern method for visitors with a return value
        /// 
        /// The visitor
        /// The node in question 
        /// An instance of TResultType
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); } 
        #endregion
    } 

    /// 
    /// A Constrained SortOp. Used to represent physical paging (skip, limit, skip + limit) operations.
    ///  
    internal sealed class ConstrainedSortOp : SortBaseOp
    { 
        #region private state 
        private bool _withTies;
        #endregion 

        #region constructors
        // Pattern constructor
        private ConstrainedSortOp() : base(OpType.ConstrainedSort) { } 

        internal ConstrainedSortOp(List sortKeys, bool withTies) 
            : base(OpType.ConstrainedSort, sortKeys) 
        {
            _withTies = withTies; 
        }
        #endregion

        #region public methods 
        internal bool WithTies { get { return _withTies; } set { _withTies = value; } }
 
        internal static readonly ConstrainedSortOp Pattern = new ConstrainedSortOp(); 

        ///  
        /// 3 children - the input, a possibly NullOp limit and a possibly NullOp skip count.
        /// 
        internal override int Arity { get { return 3; } }
 
        /// 
        /// Visitor pattern method 
        ///  
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op 
        [DebuggerNonUserCode]
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }

        ///  
        /// Visitor pattern method for visitors with a return value
        ///  
        /// The visitor 
        /// The node in question
        /// An instance of TResultType 
        [DebuggerNonUserCode]
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion
    } 

    ///  
    /// GroupByBaseOp 
    /// 
    internal abstract class GroupByBaseOp : RelOp 
    {
        #region private state
        private VarVec m_keys;
        private VarVec m_outputs; 
        #endregion
 
        #region constructors 
        protected GroupByBaseOp(OpType opType) : base(opType)
        { 
            Debug.Assert(opType == OpType.GroupBy || opType == OpType.GroupByInto, "GroupByBaseOp OpType must be GroupBy or GroupByInto");
        }
        internal GroupByBaseOp(OpType opType, VarVec keys, VarVec outputs)
            : this(opType) 
        {
            m_keys = keys; 
            m_outputs = outputs; 
        }
        #endregion 

        #region public methods
        /// 
        /// GroupBy keys 
        /// 
        internal VarVec Keys { get { return m_keys; } } 
 
        /// 
        /// All outputs of this Op - includes keys and aggregates 
        /// 
        internal VarVec Outputs { get { return m_outputs; } }

        ///  
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op 
        /// The Node that references this Op
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }

        /// 
        /// Visitor pattern method for visitors with a return value 
        /// 
        /// The visitor 
        /// The node in question 
        /// An instance of TResultType
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion
    }
 
    /// 
    /// GroupByOp 
    ///  
    internal sealed class GroupByOp : GroupByBaseOp
    { 
        #region constructors
        private GroupByOp() : base(OpType.GroupBy) { }
        internal GroupByOp(VarVec keys, VarVec outputs)
            : base(OpType.GroupBy, keys, outputs) 
        {
        } 
        #endregion 

        #region public methods 
        internal static readonly GroupByOp Pattern = new GroupByOp();

        /// 
        /// 3 children - input, keys (vardeflist), aggregates (vardeflist) 
        /// 
        internal override int Arity { get { return 3; } } 
 
        /// 
        /// Visitor pattern method 
        /// 
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
 
        ///  
        /// Visitor pattern method for visitors with a return value
        ///  
        /// The visitor
        /// The node in question
        /// An instance of TResultType
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion 
    } 

    ///  
    /// GroupByIntoOp
    /// 
    internal sealed class GroupByIntoOp : GroupByBaseOp
    { 
        #region private state
        private readonly VarVec m_inputs; 
        #endregion 

        #region constructors 
        private GroupByIntoOp() : base(OpType.GroupByInto) { }
        internal GroupByIntoOp(VarVec keys, VarVec inputs, VarVec outputs)
            : base(OpType.GroupByInto, keys, outputs)
        { 
            this.m_inputs = inputs;
        } 
        #endregion 

        #region public methods 
        /// 
        /// GroupBy keys
        /// 
        internal VarVec Inputs { get { return m_inputs; } } 

        internal static readonly GroupByIntoOp Pattern = new GroupByIntoOp(); 
 
        /// 
        /// 4 children - input, keys (vardeflist), aggregates (vardeflist), groupaggregates (vardeflist) 
        /// 
        internal override int Arity { get { return 4; } }

        ///  
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op 
        /// The Node that references this Op
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }

        /// 
        /// Visitor pattern method for visitors with a return value 
        /// 
        /// The visitor 
        /// The node in question 
        /// An instance of TResultType
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion
    }
 
    /// 
    /// Base class for set operations - union, intersect, except 
    ///  
    internal abstract class SetOp : RelOp
    { 
        #region private state
        private VarMap[] m_varMap;
        private VarVec m_outputVars;
        #endregion 

        #region constructors 
        internal SetOp(OpType opType, VarVec outputs, VarMap left, VarMap right) 
            : this(opType)
        { 
            m_varMap = new VarMap[2];
            m_varMap[0] = left;
            m_varMap[1] = right;
            m_outputVars = outputs; 
        }
        protected SetOp(OpType opType) : base(opType) 
        { 
        }
        #endregion 

        #region public methods

        ///  
        /// 2 children - left, right
        ///  
        internal override int Arity { get { return 2; } } 

        ///  
        /// Map of result vars to the vars of each branch of the setOp
        /// 
        internal VarMap[] VarMap { get { return m_varMap; } }
 
        /// 
        /// Get the set of output vars produced 
        ///  
        internal VarVec Outputs { get { return m_outputVars; } }
        #endregion 
    }

    /// 
    /// UnionAll (ie) no duplicate elimination 
    /// 
    internal sealed class UnionAllOp : SetOp 
    { 
        #region private state
        private Var m_branchDiscriminator; 
        #endregion

        #region constructors
        private UnionAllOp() : base(OpType.UnionAll) { } 

        internal UnionAllOp(VarVec outputs, VarMap left, VarMap right, Var branchDiscriminator) : base(OpType.UnionAll, outputs, left, right) 
        { 
            m_branchDiscriminator = branchDiscriminator;
        } 
        #endregion

        #region public methods
        internal static readonly UnionAllOp Pattern = new UnionAllOp(); 

        ///  
        /// Returns the branch discriminator var for this op.  It may be null, if 
        /// we haven't been through key pullup yet.
        ///  
        internal Var BranchDiscriminator { get { return m_branchDiscriminator; } }

        /// 
        /// Visitor pattern method 
        /// 
        /// The BasicOpVisitor that is visiting this Op 
        /// The Node that references this Op 
        [DebuggerNonUserCode]
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 

        /// 
        /// Visitor pattern method for visitors with a return value
        ///  
        /// The visitor
        /// The node in question 
        /// An instance of TResultType 
        [DebuggerNonUserCode]
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); } 
        #endregion
    }

    ///  
    /// An IntersectOp
    ///  
    internal sealed class IntersectOp : SetOp 
    {
        #region constructors 
        private IntersectOp() : base(OpType.Intersect) { }
        internal IntersectOp(VarVec outputs, VarMap left, VarMap right) : base(OpType.Intersect, outputs, left,right) { }
#endregion
 
        #region public methods
        internal static readonly IntersectOp Pattern = new IntersectOp(); 
 
        /// 
        /// Visitor pattern method 
        /// 
        /// The BasicOpVisitor that is visiting this Op
        /// The Node that references this Op
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }
 
        ///  
        /// Visitor pattern method for visitors with a return value
        ///  
        /// The visitor
        /// The node in question
        /// An instance of TResultType
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion 
    } 

    ///  
    /// ExceptOp (Minus)
    /// 
    internal sealed class ExceptOp : SetOp
    { 
        #region constructors
        private ExceptOp() : base(OpType.Except) { } 
        internal ExceptOp(VarVec outputs, VarMap left, VarMap right) : base(OpType.Except, outputs, left, right) { } 
        #endregion
 
        #region public methods
        internal static readonly ExceptOp Pattern = new ExceptOp();

        ///  
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op 
        /// The Node that references this Op
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }

        /// 
        /// Visitor pattern method for visitors with a return value 
        /// 
        /// The visitor 
        /// The node in question 
        /// An instance of TResultType
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }
        #endregion
    }
 
    /// 
    /// DistinctOp 
    ///  
    internal sealed class DistinctOp : RelOp
    { 
        #region private state
        private VarVec m_keys;
        #endregion
 
        #region constructors
        private DistinctOp() : base(OpType.Distinct) 
        { 
        }
        internal DistinctOp(VarVec keyVars) : this() 
        {
            Debug.Assert(keyVars != null);
            Debug.Assert(!keyVars.IsEmpty);
            m_keys = keyVars; 
        }
        #endregion 
 
        #region public methods
        internal static readonly DistinctOp Pattern = new DistinctOp(); 

        /// 
        /// 1 child - input
        ///  
        internal override int Arity { get { return 1; } }
 
        ///  
        /// Get "key" vars for the distinct
        ///  
        internal VarVec Keys { get { return m_keys; } }

        /// 
        /// Visitor pattern method 
        /// 
        /// The BasicOpVisitor that is visiting this Op 
        /// The Node that references this Op 
        [DebuggerNonUserCode]
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 

        /// 
        /// Visitor pattern method for visitors with a return value
        ///  
        /// The visitor
        /// The node in question 
        /// An instance of TResultType 
        [DebuggerNonUserCode]
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); } 
        #endregion
    }

    ///  
    /// Selects out a single row from a underlying subquery. Two flavors of this Op exist.
    /// The first flavor enforces the single-row-ness (ie) an error is raised if the 
    /// underlying subquery produces more than one row. 
    /// The other flavor simply choses any row from the input
    ///  
    internal sealed class SingleRowOp : RelOp
    {
        #region constructors
        private SingleRowOp() : base(OpType.SingleRow) { } 
        #endregion
 
        #region public methods 
        /// 
        /// Singleton instance 
        /// 
        internal static readonly SingleRowOp Instance = new SingleRowOp();
        /// 
        /// Pattern for transformation rules 
        /// 
        internal static readonly SingleRowOp Pattern = Instance; 
 
        /// 
        /// 1 child - input 
        /// 
        internal override int Arity { get { return 1; } }

        ///  
        /// Visitor pattern method
        ///  
        /// The BasicOpVisitor that is visiting this Op 
        /// The Node that references this Op
        [DebuggerNonUserCode] 
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); }

        /// 
        /// Visitor pattern method for visitors with a return value 
        /// 
        /// The visitor 
        /// The node in question 
        /// An instance of TResultType
        [DebuggerNonUserCode] 
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); }

        #endregion
    } 

    ///  
    /// Represents a table with a single row 
    /// 
    internal sealed class SingleRowTableOp : RelOp 
    {
        #region constructors
        private SingleRowTableOp() : base(OpType.SingleRowTable) { }
        #endregion 

        #region public methods 
        ///  
        /// Singleton instance
        ///  
        internal static readonly SingleRowTableOp Instance = new SingleRowTableOp();
        /// 
        /// Pattern for transformation rules
        ///  
        internal static readonly SingleRowTableOp Pattern = Instance;
 
        ///  
        /// 0 children
        ///  
        internal override int Arity { get { return 0; } }

        /// 
        /// Visitor pattern method 
        /// 
        /// The BasicOpVisitor that is visiting this Op 
        /// The Node that references this Op 
        [DebuggerNonUserCode]
        internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 

        /// 
        /// Visitor pattern method for visitors with a return value
        ///  
        /// The visitor
        /// The node in question 
        /// An instance of TResultType 
        [DebuggerNonUserCode]
        internal override TResultType Accept(BasicOpVisitorOfT v, Node n) { return v.Visit(this, n); } 

        #endregion
    }
 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK