Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / ndp / fx / src / DataEntity / System / Data / Query / PlanCompiler / PlanCompiler.cs / 2 / PlanCompiler.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....], [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Diagnostics; // Please use PlanCompiler.Assert instead of Debug.Assert in this class...
using cqt = System.Data.Common.CommandTrees;
using md = System.Data.Metadata.Edm;
using System.Data.Query.InternalTrees;
using System.Data.Query.PlanCompiler;
namespace System.Data.Query.PlanCompiler
{
///
/// The PlanCompiler class is used by the BridgeCommand to produce an
/// execution plan - this execution plan is the plan object. The plan compilation
/// process takes as input a command tree (in C space), and then runs through a
/// set of changes before the final plan is produced. The final plan contains
/// one or more command trees (commands?) (in S space), with a set of assembly
/// instructions.
/// The compiler phases include
/// * Convert the command tree (CTree) into an internal tree (an ITree)
/// * Run initializations on the ITree.
/// * Eliminate structured types from the tree
/// * Eliminating named type references, refs and records from the tree
/// At the end of this phase, we still may have collections (and record
/// arguments to collections) in the tree.
/// * Projection pruning (ie) eliminating unused references
/// * Tree transformations. Various transformations are run on the ITree to
/// (ostensibly) optimize the tree. These transformations are represented as
/// rules, and a rule processor is invoked.
/// * Nest elimination. At this point, we try to get pull up nest operations
/// as high up the tree as possible
/// * Code Generation. This phase produces a plan object with various subpieces
/// of the ITree represented as commands (in S space).
/// * The subtrees of the ITree are then converted into the corresponding CTrees
/// and converted into S space as part of the CTree creation.
/// * A plan object is created and returned.
///
internal class PlanCompiler {
#region private state
///
/// Bid Counter object
///
private static int _objectTypeCount;
///
/// The object Id of this instance, for BID tracing.
///
internal readonly int ObjectID = System.Threading.Interlocked.Increment(ref _objectTypeCount);
///
/// A boolean switch indicating whether we should apply transformation rules regardless of the size of the Iqt.
/// By default, the Enabled property of a boolean switch is set using the value specified in the configuration file.
/// Configuring the switch with a value of 0 sets the Enabled property to false; configuring the switch with a nonzero
/// value to set the Enabled property to true. If the BooleanSwitch constructor cannot find initial switch settings
/// in the configuration file, the Enabled property of the new switch is set to false by default.
///
private static BooleanSwitch _applyTransformationsRegardlessOfSize = new BooleanSwitch("System.Data.EntityClient.IgnoreOptimizationLimit", "The Entity Framework should try to optimize the query regardless of its size");
///
/// Determines the maximum size of the query in terms of Iqt nodes for which we attempt to do transformation rules.
/// This number is ignored if applyTransformationsRegardlessOfSize is enabled.
///
private const int MaxNodeCountForTransformations = 100000;
///
/// The CTree we're compiling a plan for.
///
private cqt.DbCommandTree m_ctree;
///
/// The ITree we're working on.
///
private Command m_command;
///
/// The phase of the process we're currently in.
///
private PlanCompilerPhase m_phase;
///
/// Set of phases we need to go through
///
private int m_neededPhases;
#endregion
#region constructors
///
/// private constructor
///
/// the input cqt
private PlanCompiler(cqt.DbCommandTree ctree) {
m_ctree = ctree; // the input command tree
}
#endregion
#region public interfaces
internal const Bid.ApiGroup PlanCompilerTracePoints = (Bid.ApiGroup)0x8000; // That's Bit_15 for those counting at home :)
///
/// Retail Assertion code.
///
/// Provides the ability to have retail asserts.
///
///
///
internal static void Assert(bool condition, string message) {
if (!condition) {
System.Diagnostics.Debug.Fail(message);
// NOTE: I considered, at great length, whether to have the assertion message text
// included in the exception we throw; in the end, there really isn't a reliable
// equivalent to the C++ __LINE__ and __FILE__ macros in C# (at least not without
// using the C++ PreProcessor...ick) The StackTrace object comes close but
// doesn't handle inlined callers properly for our needs (MethodA() calls MethodB()
// calls us, but MethodB() is inlined, so we'll get MethodA() info instead), and
// since these are retail "Asserts" (as in: we're not supposed to get them in our
// shipping code, and we're doing this to avoid a null-ref which is even worse) I
// elected to simplify this by just including them as the additional info.
throw EntityUtil.InternalError(EntityUtil.InternalErrorCode.AssertionFailed, 0, message);
}
}
///
/// Compile a query, and produce a plan
///
/// the input CQT
/// list of provider commands
/// column map for result assembly
/// the entity sets referenced in this query
/// a compiled plan object
internal static void Compile(cqt.DbCommandTree ctree, out List providerCommands, out ColumnMap resultColumnMap, out int columnCount, out Common.Utils.Set entitySets) {
PlanCompiler.Assert(ctree != null, "Expected a valid, non-null Command Tree input");
PlanCompiler pc = new PlanCompiler(ctree);
pc.Compile(out providerCommands, out resultColumnMap, out columnCount, out entitySets);
}
///
/// Get the current command
///
internal Command Command { get { return m_command; } }
#if DEBUG
///
/// Get the current plan compiler phase
///
internal PlanCompilerPhase Phase { get { return m_phase; } }
#endif
///
/// The MetadataWorkspace
///
internal md.MetadataWorkspace MetadataWorkspace { get { return m_ctree.MetadataWorkspace; } }
///
/// Is the specified phase needed for this query?
///
/// the phase in question
///
/// Mark the specified phase as needed
///
/// plan compiler phase
internal void MarkPhaseAsNeeded(PlanCompilerPhase phase) {
m_neededPhases = m_neededPhases | (1 << (int)phase);
}
///
/// Mark the specified phase as not needed
///
/// plan compiler phase
internal void MarkPhaseAsNotNeeded(PlanCompilerPhase phase) {
m_neededPhases = m_neededPhases & (~0 ^ (1 << (int)phase));
}
#endregion
#region private methods
///
/// The real driver.
///
/// list of provider commands
/// column map for the result
/// the entity sets exposed in this query
private void Compile(out List providerCommands, out ColumnMap resultColumnMap, out int columnCount, out Common.Utils.Set entitySets) {
EntityBid.Trace(" %d# Compiling Plan for DbCommandTree=%d#\n", ObjectID, m_ctree.ObjectId);
Initialize(); // initialize the ITree
string beforePreProcessor = String.Empty;
string beforeNTE = String.Empty;
string beforeProjectionPruning1 = String.Empty;
string beforeNestPullup = String.Empty;
string beforeProjectionPruning2 = String.Empty;
string beforeTransformationRules = String.Empty;
string beforeProjectionPruning3 = String.Empty;
string beforeJoinElimination = String.Empty;
string beforeCodeGen = String.Empty;
//
// We always need the pre-processor and the codegen phases.
// It is generally a good thing to run through the transformation rules, and
// the projection pruning phases.
// The "optional" phases are NTE, NestPullup and JoinElimination
//
m_neededPhases = (1 << (int)PlanCompilerPhase.PreProcessor) |
// (1 << (int)PlanCompilerPhase.NTE) |
(1 << (int)PlanCompilerPhase.ProjectionPruning) |
// (1 << (int)PlanCompilerPhase.NestPullup) |
(1 << (int)PlanCompilerPhase.Transformations) |
// (1 << (int)PlanCompilerPhase.JoinElimination) |
(1 << (int)PlanCompilerPhase.CodeGen);
// Perform any necessary preprocessing
StructuredTypeInfo typeInfo = null;
beforePreProcessor = SwitchToPhase(PlanCompilerPhase.PreProcessor);
PreProcessor.Process(this, out typeInfo);
entitySets = typeInfo.GetEntitySets();
// Eliminate "structured" types.
if (IsPhaseNeeded(PlanCompilerPhase.NTE)) {
beforeNTE = SwitchToPhase(PlanCompilerPhase.NTE);
NominalTypeEliminator.Process(this, typeInfo);
}
// Projection pruning - eliminate unreferenced expressions
if (IsPhaseNeeded(PlanCompilerPhase.ProjectionPruning)) {
beforeProjectionPruning1 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning);
ProjectionPruner.Process(this);
}
// Nest Pull-up on the ITree
if (IsPhaseNeeded(PlanCompilerPhase.NestPullup)) {
beforeNestPullup = SwitchToPhase(PlanCompilerPhase.NestPullup);
NestPullup.Process(this);
//If we do Nest Pull-up, we should again do projection pruning
beforeProjectionPruning2 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning);
ProjectionPruner.Process(this);
}
// Run transformations on the tree
if (IsPhaseNeeded(PlanCompilerPhase.Transformations) && MayApplyTransformationRules()) {
//Clear the projection pruning phase, transformation rules will set it again if needed.
MarkPhaseAsNotNeeded(PlanCompilerPhase.ProjectionPruning);
beforeTransformationRules = SwitchToPhase(PlanCompilerPhase.Transformations);
TransformationRules.ApplyAllRules(this);
if (IsPhaseNeeded(PlanCompilerPhase.ProjectionPruning)) {
beforeProjectionPruning3 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning);
ProjectionPruner.Process(this);
TransformationRules.ApplyProjectRules(this);
}
}
// Join elimination
if (IsPhaseNeeded(PlanCompilerPhase.JoinElimination)) {
//Clear the transformation rules phase, join elimination will set it again if needed.
MarkPhaseAsNotNeeded(PlanCompilerPhase.Transformations);
beforeJoinElimination = SwitchToPhase(PlanCompilerPhase.JoinElimination);
JoinElimination.Process(this);
if (IsPhaseNeeded(PlanCompilerPhase.Transformations) && MayApplyTransformationRules()) {
TransformationRules.ApplyKeyInfoDependentRules(this);
}
}
// Code generation
beforeCodeGen = SwitchToPhase(PlanCompilerPhase.CodeGen);
CodeGen.Process(this, out providerCommands, out resultColumnMap, out columnCount);
#if DEBUG
// GC.KeepAlive makes FxCop Grumpy.
int size = beforePreProcessor.Length;
size = beforeNTE.Length;
size = beforeProjectionPruning1.Length;
size = beforeNestPullup.Length;
size = beforeProjectionPruning2.Length;
size = beforeTransformationRules.Length;
size = beforeProjectionPruning3.Length;
size = beforeJoinElimination.Length;
size = beforeCodeGen.Length;
#endif
if (EntityBid.TraceOn) {
int i = 0;
foreach (ProviderCommandInfo pi in providerCommands) {
EntityBid.Trace(" %d# resulting command %d with DbCommandTree=%d#\n", ObjectID, i++, pi.CommandTree.ObjectId);
}
}
// All done
return;
}
///
/// Logic to perform between each compile phase
///
///
/// %d# phase=%d\n", ObjectID, (int)newPhase);
EntityBid.PlanCompilerPutStr(iqtDumpResult);
}
#if DEBUG
else {
iqtDumpResult = Dump.ToXml(m_command);
}
Validator.Validate(this);
#endif
return iqtDumpResult;
}
///
/// Transformation rules may be applied if the number of nodes is less then MaxNodeCountForTransformations
/// or it is specified that they may be applied regardless of the size of the query.
/// We approximate the number of nodes by looking at the nextNodeId.
///
///
/// Converts the CTree into an ITree, and initializes the plan
///
private void Initialize() {
// Only support queries for now
cqt.DbQueryCommandTree cqtree = m_ctree as cqt.DbQueryCommandTree;
PlanCompiler.Assert(cqtree != null, "Unexpected command tree kind. Only query command tree is supported.");
// Generate the ITree
m_command = ITreeGenerator.Generate(cqtree);
PlanCompiler.Assert(m_command != null, "Unable to generate internal tree from Command Tree");
}
#endregion
}
///
/// Enum describing which phase of plan compilation we're currently in
///
internal enum PlanCompilerPhase {
///
/// Just entering the PreProcessor phase
///
PreProcessor = 0,
///
/// Just entering the NTE (Nominal Type Eliminator) phase
///
NTE = 1,
///
/// Entering the Projection pruning phase
///
ProjectionPruning = 2,
///
/// Entering the Nest Pullup phase
///
NestPullup = 3,
///
/// Entering the Transformations phase
///
Transformations = 4,
///
/// Entering the JoinElimination phase
///
JoinElimination = 5,
///
/// Entering the codegen phase
///
CodeGen = 6,
///
/// We're almost done
///
PostCodeGen = 7,
///
/// Marker
///
MaxMarker = 8
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....], [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Diagnostics; // Please use PlanCompiler.Assert instead of Debug.Assert in this class...
using cqt = System.Data.Common.CommandTrees;
using md = System.Data.Metadata.Edm;
using System.Data.Query.InternalTrees;
using System.Data.Query.PlanCompiler;
namespace System.Data.Query.PlanCompiler
{
///
/// The PlanCompiler class is used by the BridgeCommand to produce an
/// execution plan - this execution plan is the plan object. The plan compilation
/// process takes as input a command tree (in C space), and then runs through a
/// set of changes before the final plan is produced. The final plan contains
/// one or more command trees (commands?) (in S space), with a set of assembly
/// instructions.
/// The compiler phases include
/// * Convert the command tree (CTree) into an internal tree (an ITree)
/// * Run initializations on the ITree.
/// * Eliminate structured types from the tree
/// * Eliminating named type references, refs and records from the tree
/// At the end of this phase, we still may have collections (and record
/// arguments to collections) in the tree.
/// * Projection pruning (ie) eliminating unused references
/// * Tree transformations. Various transformations are run on the ITree to
/// (ostensibly) optimize the tree. These transformations are represented as
/// rules, and a rule processor is invoked.
/// * Nest elimination. At this point, we try to get pull up nest operations
/// as high up the tree as possible
/// * Code Generation. This phase produces a plan object with various subpieces
/// of the ITree represented as commands (in S space).
/// * The subtrees of the ITree are then converted into the corresponding CTrees
/// and converted into S space as part of the CTree creation.
/// * A plan object is created and returned.
///
internal class PlanCompiler {
#region private state
///
/// Bid Counter object
///
private static int _objectTypeCount;
///
/// The object Id of this instance, for BID tracing.
///
internal readonly int ObjectID = System.Threading.Interlocked.Increment(ref _objectTypeCount);
///
/// A boolean switch indicating whether we should apply transformation rules regardless of the size of the Iqt.
/// By default, the Enabled property of a boolean switch is set using the value specified in the configuration file.
/// Configuring the switch with a value of 0 sets the Enabled property to false; configuring the switch with a nonzero
/// value to set the Enabled property to true. If the BooleanSwitch constructor cannot find initial switch settings
/// in the configuration file, the Enabled property of the new switch is set to false by default.
///
private static BooleanSwitch _applyTransformationsRegardlessOfSize = new BooleanSwitch("System.Data.EntityClient.IgnoreOptimizationLimit", "The Entity Framework should try to optimize the query regardless of its size");
///
/// Determines the maximum size of the query in terms of Iqt nodes for which we attempt to do transformation rules.
/// This number is ignored if applyTransformationsRegardlessOfSize is enabled.
///
private const int MaxNodeCountForTransformations = 100000;
///
/// The CTree we're compiling a plan for.
///
private cqt.DbCommandTree m_ctree;
///
/// The ITree we're working on.
///
private Command m_command;
///
/// The phase of the process we're currently in.
///
private PlanCompilerPhase m_phase;
///
/// Set of phases we need to go through
///
private int m_neededPhases;
#endregion
#region constructors
///
/// private constructor
///
/// the input cqt
private PlanCompiler(cqt.DbCommandTree ctree) {
m_ctree = ctree; // the input command tree
}
#endregion
#region public interfaces
internal const Bid.ApiGroup PlanCompilerTracePoints = (Bid.ApiGroup)0x8000; // That's Bit_15 for those counting at home :)
///
/// Retail Assertion code.
///
/// Provides the ability to have retail asserts.
///
///
///
internal static void Assert(bool condition, string message) {
if (!condition) {
System.Diagnostics.Debug.Fail(message);
// NOTE: I considered, at great length, whether to have the assertion message text
// included in the exception we throw; in the end, there really isn't a reliable
// equivalent to the C++ __LINE__ and __FILE__ macros in C# (at least not without
// using the C++ PreProcessor...ick) The StackTrace object comes close but
// doesn't handle inlined callers properly for our needs (MethodA() calls MethodB()
// calls us, but MethodB() is inlined, so we'll get MethodA() info instead), and
// since these are retail "Asserts" (as in: we're not supposed to get them in our
// shipping code, and we're doing this to avoid a null-ref which is even worse) I
// elected to simplify this by just including them as the additional info.
throw EntityUtil.InternalError(EntityUtil.InternalErrorCode.AssertionFailed, 0, message);
}
}
///
/// Compile a query, and produce a plan
///
/// the input CQT
/// list of provider commands
/// column map for result assembly
/// the entity sets referenced in this query
/// a compiled plan object
internal static void Compile(cqt.DbCommandTree ctree, out List providerCommands, out ColumnMap resultColumnMap, out int columnCount, out Common.Utils.Set entitySets) {
PlanCompiler.Assert(ctree != null, "Expected a valid, non-null Command Tree input");
PlanCompiler pc = new PlanCompiler(ctree);
pc.Compile(out providerCommands, out resultColumnMap, out columnCount, out entitySets);
}
///
/// Get the current command
///
internal Command Command { get { return m_command; } }
#if DEBUG
///
/// Get the current plan compiler phase
///
internal PlanCompilerPhase Phase { get { return m_phase; } }
#endif
///
/// The MetadataWorkspace
///
internal md.MetadataWorkspace MetadataWorkspace { get { return m_ctree.MetadataWorkspace; } }
///
/// Is the specified phase needed for this query?
///
/// the phase in question
///
/// Mark the specified phase as needed
///
/// plan compiler phase
internal void MarkPhaseAsNeeded(PlanCompilerPhase phase) {
m_neededPhases = m_neededPhases | (1 << (int)phase);
}
///
/// Mark the specified phase as not needed
///
/// plan compiler phase
internal void MarkPhaseAsNotNeeded(PlanCompilerPhase phase) {
m_neededPhases = m_neededPhases & (~0 ^ (1 << (int)phase));
}
#endregion
#region private methods
///
/// The real driver.
///
/// list of provider commands
/// column map for the result
/// the entity sets exposed in this query
private void Compile(out List providerCommands, out ColumnMap resultColumnMap, out int columnCount, out Common.Utils.Set entitySets) {
EntityBid.Trace(" %d# Compiling Plan for DbCommandTree=%d#\n", ObjectID, m_ctree.ObjectId);
Initialize(); // initialize the ITree
string beforePreProcessor = String.Empty;
string beforeNTE = String.Empty;
string beforeProjectionPruning1 = String.Empty;
string beforeNestPullup = String.Empty;
string beforeProjectionPruning2 = String.Empty;
string beforeTransformationRules = String.Empty;
string beforeProjectionPruning3 = String.Empty;
string beforeJoinElimination = String.Empty;
string beforeCodeGen = String.Empty;
//
// We always need the pre-processor and the codegen phases.
// It is generally a good thing to run through the transformation rules, and
// the projection pruning phases.
// The "optional" phases are NTE, NestPullup and JoinElimination
//
m_neededPhases = (1 << (int)PlanCompilerPhase.PreProcessor) |
// (1 << (int)PlanCompilerPhase.NTE) |
(1 << (int)PlanCompilerPhase.ProjectionPruning) |
// (1 << (int)PlanCompilerPhase.NestPullup) |
(1 << (int)PlanCompilerPhase.Transformations) |
// (1 << (int)PlanCompilerPhase.JoinElimination) |
(1 << (int)PlanCompilerPhase.CodeGen);
// Perform any necessary preprocessing
StructuredTypeInfo typeInfo = null;
beforePreProcessor = SwitchToPhase(PlanCompilerPhase.PreProcessor);
PreProcessor.Process(this, out typeInfo);
entitySets = typeInfo.GetEntitySets();
// Eliminate "structured" types.
if (IsPhaseNeeded(PlanCompilerPhase.NTE)) {
beforeNTE = SwitchToPhase(PlanCompilerPhase.NTE);
NominalTypeEliminator.Process(this, typeInfo);
}
// Projection pruning - eliminate unreferenced expressions
if (IsPhaseNeeded(PlanCompilerPhase.ProjectionPruning)) {
beforeProjectionPruning1 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning);
ProjectionPruner.Process(this);
}
// Nest Pull-up on the ITree
if (IsPhaseNeeded(PlanCompilerPhase.NestPullup)) {
beforeNestPullup = SwitchToPhase(PlanCompilerPhase.NestPullup);
NestPullup.Process(this);
//If we do Nest Pull-up, we should again do projection pruning
beforeProjectionPruning2 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning);
ProjectionPruner.Process(this);
}
// Run transformations on the tree
if (IsPhaseNeeded(PlanCompilerPhase.Transformations) && MayApplyTransformationRules()) {
//Clear the projection pruning phase, transformation rules will set it again if needed.
MarkPhaseAsNotNeeded(PlanCompilerPhase.ProjectionPruning);
beforeTransformationRules = SwitchToPhase(PlanCompilerPhase.Transformations);
TransformationRules.ApplyAllRules(this);
if (IsPhaseNeeded(PlanCompilerPhase.ProjectionPruning)) {
beforeProjectionPruning3 = SwitchToPhase(PlanCompilerPhase.ProjectionPruning);
ProjectionPruner.Process(this);
TransformationRules.ApplyProjectRules(this);
}
}
// Join elimination
if (IsPhaseNeeded(PlanCompilerPhase.JoinElimination)) {
//Clear the transformation rules phase, join elimination will set it again if needed.
MarkPhaseAsNotNeeded(PlanCompilerPhase.Transformations);
beforeJoinElimination = SwitchToPhase(PlanCompilerPhase.JoinElimination);
JoinElimination.Process(this);
if (IsPhaseNeeded(PlanCompilerPhase.Transformations) && MayApplyTransformationRules()) {
TransformationRules.ApplyKeyInfoDependentRules(this);
}
}
// Code generation
beforeCodeGen = SwitchToPhase(PlanCompilerPhase.CodeGen);
CodeGen.Process(this, out providerCommands, out resultColumnMap, out columnCount);
#if DEBUG
// GC.KeepAlive makes FxCop Grumpy.
int size = beforePreProcessor.Length;
size = beforeNTE.Length;
size = beforeProjectionPruning1.Length;
size = beforeNestPullup.Length;
size = beforeProjectionPruning2.Length;
size = beforeTransformationRules.Length;
size = beforeProjectionPruning3.Length;
size = beforeJoinElimination.Length;
size = beforeCodeGen.Length;
#endif
if (EntityBid.TraceOn) {
int i = 0;
foreach (ProviderCommandInfo pi in providerCommands) {
EntityBid.Trace(" %d# resulting command %d with DbCommandTree=%d#\n", ObjectID, i++, pi.CommandTree.ObjectId);
}
}
// All done
return;
}
///
/// Logic to perform between each compile phase
///
///
/// %d# phase=%d\n", ObjectID, (int)newPhase);
EntityBid.PlanCompilerPutStr(iqtDumpResult);
}
#if DEBUG
else {
iqtDumpResult = Dump.ToXml(m_command);
}
Validator.Validate(this);
#endif
return iqtDumpResult;
}
///
/// Transformation rules may be applied if the number of nodes is less then MaxNodeCountForTransformations
/// or it is specified that they may be applied regardless of the size of the query.
/// We approximate the number of nodes by looking at the nextNodeId.
///
///
/// Converts the CTree into an ITree, and initializes the plan
///
private void Initialize() {
// Only support queries for now
cqt.DbQueryCommandTree cqtree = m_ctree as cqt.DbQueryCommandTree;
PlanCompiler.Assert(cqtree != null, "Unexpected command tree kind. Only query command tree is supported.");
// Generate the ITree
m_command = ITreeGenerator.Generate(cqtree);
PlanCompiler.Assert(m_command != null, "Unable to generate internal tree from Command Tree");
}
#endregion
}
///
/// Enum describing which phase of plan compilation we're currently in
///
internal enum PlanCompilerPhase {
///
/// Just entering the PreProcessor phase
///
PreProcessor = 0,
///
/// Just entering the NTE (Nominal Type Eliminator) phase
///
NTE = 1,
///
/// Entering the Projection pruning phase
///
ProjectionPruning = 2,
///
/// Entering the Nest Pullup phase
///
NestPullup = 3,
///
/// Entering the Transformations phase
///
Transformations = 4,
///
/// Entering the JoinElimination phase
///
JoinElimination = 5,
///
/// Entering the codegen phase
///
CodeGen = 6,
///
/// We're almost done
///
PostCodeGen = 7,
///
/// Marker
///
MaxMarker = 8
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- TextEditorTables.cs
- AdapterUtil.cs
- MenuBase.cs
- PropertyCondition.cs
- GenericParameterDataContract.cs
- _ConnectOverlappedAsyncResult.cs
- NegotiationTokenAuthenticatorStateCache.cs
- ItemsChangedEventArgs.cs
- ImageMap.cs
- EntityDataSourceReferenceGroup.cs
- BitmapCacheBrush.cs
- PreservationFileReader.cs
- HttpListenerContext.cs
- StylusTip.cs
- SqlClientWrapperSmiStreamChars.cs
- ListItem.cs
- DataGridCellItemAutomationPeer.cs
- FormsIdentity.cs
- Dictionary.cs
- ContainerParagraph.cs
- TableCellAutomationPeer.cs
- Privilege.cs
- CroppedBitmap.cs
- TargetControlTypeCache.cs
- FixedSOMContainer.cs
- EmissiveMaterial.cs
- HatchBrush.cs
- LineBreak.cs
- ToolboxControl.cs
- HtmlElementCollection.cs
- cryptoapiTransform.cs
- EllipseGeometry.cs
- OleDbCommand.cs
- ParameterCollection.cs
- ClientProxyGenerator.cs
- StylusTouchDevice.cs
- StyleCollection.cs
- FontNamesConverter.cs
- MetadataArtifactLoader.cs
- MessageAction.cs
- HeaderedContentControl.cs
- ConsoleEntryPoint.cs
- Collection.cs
- XmlToDatasetMap.cs
- TextPatternIdentifiers.cs
- MembershipSection.cs
- SecurityMode.cs
- BitmapMetadataBlob.cs
- SerialStream.cs
- ImpersonationContext.cs
- DefaultValidator.cs
- EpmSyndicationContentSerializer.cs
- ServiceDesigner.cs
- NodeInfo.cs
- Compiler.cs
- FilterElement.cs
- FrameworkEventSource.cs
- TabControlEvent.cs
- X509Logo.cs
- MarkupProperty.cs
- Item.cs
- Knowncolors.cs
- ListView.cs
- CodeIdentifier.cs
- _PooledStream.cs
- CollectionBuilder.cs
- StylusEventArgs.cs
- Dictionary.cs
- SeverityFilter.cs
- StaticDataManager.cs
- XamlUtilities.cs
- ItemCollection.cs
- TerminatorSinks.cs
- TreeNodeMouseHoverEvent.cs
- ContractSearchPattern.cs
- JsonReader.cs
- SchemaAttDef.cs
- isolationinterop.cs
- TextParagraph.cs
- XomlCompilerParameters.cs
- ProfileProvider.cs
- IriParsingElement.cs
- DispatcherEventArgs.cs
- DataObjectFieldAttribute.cs
- IndependentlyAnimatedPropertyMetadata.cs
- TextRangeProviderWrapper.cs
- SimpleHandlerBuildProvider.cs
- ISAPIWorkerRequest.cs
- TextServicesContext.cs
- StatusBar.cs
- SymLanguageVendor.cs
- CapabilitiesPattern.cs
- HttpHandlersSection.cs
- BrowserCapabilitiesFactoryBase.cs
- Monitor.cs
- PageThemeParser.cs
- SafeBuffer.cs
- DocumentEventArgs.cs
- ScrollContentPresenter.cs
- NamedPipeDuplicateContext.cs