PhysicalOps.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 / PhysicalOps.cs / 1305376 / PhysicalOps.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.Data.Query.PlanCompiler;
using md = System.Data.Metadata.Edm; 
 
namespace System.Data.Query.InternalTrees
{ 
    /// 
    /// A PhysicalProjectOp is a physical Op capping the entire command tree (and the
    /// subtrees of CollectOps).
    ///  
    internal class PhysicalProjectOp : PhysicalOp
    { 
        #region public methods 
        /// 
        /// Instance for pattern matching in rules 
        /// 
        internal static readonly PhysicalProjectOp Pattern = new PhysicalProjectOp();

        ///  
        /// Get the column map that describes how the result should be reshaped
        ///  
        internal SimpleCollectionColumnMap ColumnMap 
        {
            get { return m_columnMap; } 
        }

        /// 
        /// Get the (ordered) list of output vars that this node produces 
        /// 
        internal VarList Outputs 
        { 
            get { return m_outputVars; }
        } 

        /// 
        /// 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

        #region private constructors
        ///  
        /// basic constructor
        ///  
        /// List of outputs from this Op 
        /// column map that describes the result to be shaped
        internal PhysicalProjectOp(VarList outputVars, SimpleCollectionColumnMap columnMap) 
            : this()
        {
            Debug.Assert(null != columnMap, "null columnMap?");
            m_outputVars = outputVars; 
            m_columnMap = columnMap;
        } 
 
        private PhysicalProjectOp()
            : base(OpType.PhysicalProject) 
        {
        }
        #endregion
 
        #region private state
        private SimpleCollectionColumnMap m_columnMap; 
        private VarList m_outputVars; 
        #endregion
    } 

    /// 
    /// Represents information about one collection being managed by the NestOps.
    /// The CollectionVar is a Var that represents the entire collection. 
    /// 
    internal class CollectionInfo 
    { 
        #region public methods
        ///  
        /// The collection-var
        /// 
        internal Var CollectionVar
        { 
            get { return m_collectionVar; }
        } 
        ///  
        /// the column map for the collection element
        ///  
        internal ColumnMap ColumnMap
        {
            get { return m_columnMap; }
        } 

        ///  
        /// list of vars describing the collection element; flattened to remove 
        /// nested collections
        ///  
        internal VarList FlattenedElementVars
        {
            get { return m_flattenedElementVars; }
        } 

        ///  
        /// list of keys specific to this collection 
        /// 
        internal VarVec Keys 
        {
            get { return m_keys; }
        }
 
        /// 
        /// list of sort keys specific to this collection 
        ///  
        internal List SortKeys
        { 
            get { return m_sortKeys; }
        }

        ///  
        /// Discriminator Value for this collection (for a given NestOp).
        /// Should we break this out into a subtype of CollectionInfo 
        ///  
        internal object DiscriminatorValue
        { 
            get { return m_discriminatorValue; }
        }

        #endregion 

        #region constructors 
        internal CollectionInfo(Var collectionVar, ColumnMap columnMap, VarList flattenedElementVars, VarVec keys, List sortKeys, object discriminatorValue) 
        {
            m_collectionVar = collectionVar; 
            m_columnMap = columnMap;
            m_flattenedElementVars = flattenedElementVars;
            m_keys = keys;
            m_sortKeys = sortKeys; 
            m_discriminatorValue = discriminatorValue;
        } 
        #endregion 

        #region private state 
        private Var m_collectionVar;    // the collection Var
        private ColumnMap m_columnMap;  // column map for the collection element
        private VarList m_flattenedElementVars; // elementVars, removing collections;
        private VarVec m_keys;              //list of keys specific to this collection 
        private List m_sortKeys;          //list of sort keys specific to this collection
        private object m_discriminatorValue; 
        #endregion 
    }
 
    /// 
    /// Base class for Nest operations
    /// 
    internal abstract class NestBaseOp : PhysicalOp 
    {
        #region publics 
 
        /// 
        /// (Ordered) list of prefix sort keys (defines ordering of results) 
        /// 
        internal List PrefixSortKeys
        {
            get { return m_prefixSortKeys; } 
        }
 
        ///  
        /// Outputs of the NestOp. Includes the Keys obviously, and one Var for each of
        /// the collections produced. In addition, this may also include non-key vars 
        /// from the outer row
        /// 
        internal VarVec Outputs
        { 
            get { return m_outputs; }
        } 
 
        /// 
        /// Information about each collection managed by the NestOp 
        /// 
        internal List CollectionInfo
        {
            get { return m_collectionInfoList; } 
        }
        #endregion 
 
        #region constructors
        internal NestBaseOp(OpType opType, List prefixSortKeys, 
            VarVec outputVars,
            List collectionInfoList)
            : base(opType)
        { 
            m_outputs = outputVars;
            m_collectionInfoList = collectionInfoList; 
            m_prefixSortKeys = prefixSortKeys; 
        }
        #endregion 

        #region private state
        private List m_prefixSortKeys; // list of sort key prefixes
        private VarVec m_outputs; // list of all output vars 
        private List m_collectionInfoList;
        #endregion 
    } 

    ///  
    /// Single-stream nest aggregation Op.
    /// (Somewhat similar to a group-by op - should we merge these?)
    /// 
    internal class SingleStreamNestOp : NestBaseOp 
    {
        #region publics 
        ///  
        /// 1 child - the input
        ///  
        internal override int Arity { get { return 1; } }

        /// 
        /// The discriminator Var (when there are multiple collections) 
        /// 
        internal Var Discriminator 
        { 
            get { return m_discriminator; }
        } 
        /// 
        /// List of postfix sort keys (mostly to deal with multi-level nested collections)
        /// 
        internal List PostfixSortKeys 
        {
            get { return m_postfixSortKeys; } 
        } 
        /// 
        /// Set of keys for this nest operation 
        /// 
        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
 
        #region constructors
        internal SingleStreamNestOp(VarVec keys, 
            List prefixSortKeys, List postfixSortKeys, 
            VarVec outputVars, List collectionInfoList,
            Var discriminatorVar) 
            : base(OpType.SingleStreamNest, prefixSortKeys, outputVars, collectionInfoList)
        {
            m_keys = keys;
            m_postfixSortKeys = postfixSortKeys; 
            m_discriminator = discriminatorVar;
        } 
        #endregion 

        #region private state 
        private VarVec m_keys; // keys for this operation
        private Var m_discriminator; // Var describing the discriminator
        List m_postfixSortKeys; // list of postfix sort keys
        #endregion 
    }
 
    ///  
    /// Represents a multi-stream nest operation. The first input represents the
    /// container row, while all the other inputs represent collections 
    /// 
    internal class MultiStreamNestOp : NestBaseOp
    {
        #region publics 
        /// 
        /// 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
 
        #region constructors
        internal MultiStreamNestOp(List prefixSortKeys, VarVec outputVars, 
            List collectionInfoList) 
            : base(OpType.MultiStreamNest, prefixSortKeys, outputVars, collectionInfoList)
        { 
        }
        #endregion

        #region private state 
        #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