CodeGen.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 / PlanCompiler / CodeGen.cs / 1305376 / CodeGen.cs
                        

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

using System; 
using System.Collections.Generic;
//using System.Diagnostics; // Please use PlanCompiler.Assert instead of Debug.Assert in this class...
using System.Globalization;
using md = System.Data.Metadata.Edm; 
using System.Data.Common.CommandTrees;
using System.Data.Query.InternalTrees; 
using System.Data.Query.PlanCompiler; 

// 
// The CodeGen module is responsible for translating the ITree finally into a query
//  We assume that various tree transformations have taken place, and the tree
// is finally ready to be executed. The CodeGen module
//   * converts the Itree into one or more CTrees (in S space) 
//   * produces a ColumnMap to facilitate result assembly
//   * and wraps up everything in a plan object 
// 
//
 
namespace System.Data.Query.PlanCompiler
{
    internal class CodeGen
    { 
        #region public methods
        ///  
        /// This involves 
        ///   * Converting the ITree into a set of ProviderCommandInfo objects
        ///   * Creating a column map to enable result assembly 
        /// Currently, we only produce a single ITree, and correspondingly, the
        /// following steps are trivial
        /// 
        /// current compiler state 
        /// CQTs for each store command
        /// column map to help in result assembly 
        internal static void Process(PlanCompiler compilerState, out List childCommands, out ColumnMap resultColumnMap, out int columnCount) 
        {
            CodeGen codeGen = new CodeGen(compilerState); 
            codeGen.Process(out childCommands, out resultColumnMap, out columnCount);
        }

        #endregion 

        #region constructors 
        private CodeGen(PlanCompiler compilerState) 
        {
            m_compilerState = compilerState; 
        }
        #endregion

        #region private methods 

        ///  
        /// The real driver. This routine walks the tree, converts each subcommand 
        /// into a CTree, and converts the columnmap into a real column map.
        /// Finally, it produces a "real" plan that can be used by the bridge execution, and 
        /// returns this plan
        ///
        /// The root of the tree must be a PhysicalProjectOp. Each child of this Op
        /// represents a command to be executed, and the ColumnMap of this Op represents 
        /// the eventual columnMap to be used for result assembly
        ///  
        /// CQTs for store commands 
        /// column map for result assembly
        private void Process(out List childCommands, out ColumnMap resultColumnMap, out int columnCount) 
        {
            PhysicalProjectOp projectOp = (PhysicalProjectOp)this.Command.Root.Op;

            this.m_subCommands = new List(new Node[] { this.Command.Root }); 
            childCommands = new List(new ProviderCommandInfo[] {
                ProviderCommandInfoUtils.Create( 
                this.Command, 
                this.Command.Root                  // input node
            )}); 

            // Build the final column map, and count the columns we expect for it.
            resultColumnMap = BuildResultColumnMap(projectOp);
 
            columnCount = projectOp.Outputs.Count;
        } 
 
        private ColumnMap BuildResultColumnMap(PhysicalProjectOp projectOp)
        { 
            // convert the column map into a real column map
            // build up a dictionary mapping Vars to their real positions in the commands
            Dictionary> varMap = BuildVarMap();
            ColumnMap realColumnMap = ColumnMapTranslator.Translate(projectOp.ColumnMap, varMap); 

            return realColumnMap; 
        } 

        ///  
        /// For each subcommand, build up a "location-map" for each top-level var that
        /// is projected out. This location map will ultimately be used to convert VarRefColumnMap
        /// into SimpleColumnMap
        ///  
        private Dictionary> BuildVarMap()
        { 
            Dictionary> varMap = 
                new Dictionary>();
 
            int commandId = 0;
            foreach (Node subCommand in m_subCommands)
            {
                PhysicalProjectOp projectOp = (PhysicalProjectOp)subCommand.Op; 

                int columnPos = 0; 
                foreach (Var v in projectOp.Outputs) 
                {
                    KeyValuePair varLocation = new KeyValuePair(commandId, columnPos); 
                    varMap[v] = varLocation;
                    columnPos++;
                }
 
                commandId++;
            } 
            return varMap; 
        }
        #endregion 

        #region private state
        private PlanCompiler m_compilerState;
        private Command Command { get { return m_compilerState.Command; } } 
        private List m_subCommands;
 
        #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