diff --git a/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.cs b/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.cs index eafb79e6..2856a518 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.cs +++ b/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.cs @@ -3061,6 +3061,5390 @@ namespace Microsoft.SqlTools.ServiceLayer } } + public static string Statement + { + get + { + return Keys.GetString(Keys.Statement); + } + } + + public static string StatementDesc + { + get + { + return Keys.GetString(Keys.StatementDesc); + } + } + + public static string PhysicalOperation + { + get + { + return Keys.GetString(Keys.PhysicalOperation); + } + } + + public static string PhysicalOperationDesc + { + get + { + return Keys.GetString(Keys.PhysicalOperationDesc); + } + } + + public static string LogicalOperation + { + get + { + return Keys.GetString(Keys.LogicalOperation); + } + } + + public static string LogicalOperationDesc + { + get + { + return Keys.GetString(Keys.LogicalOperationDesc); + } + } + + public static string OperationDescriptionShort + { + get + { + return Keys.GetString(Keys.OperationDescriptionShort); + } + } + + public static string OperationDescription + { + get + { + return Keys.GetString(Keys.OperationDescription); + } + } + + public static string OperationArgumentShort + { + get + { + return Keys.GetString(Keys.OperationArgumentShort); + } + } + + public static string OperationArgumentDescription + { + get + { + return Keys.GetString(Keys.OperationArgumentDescription); + } + } + + public static string ObjectShort + { + get + { + return Keys.GetString(Keys.ObjectShort); + } + } + + public static string ObjectDescription + { + get + { + return Keys.GetString(Keys.ObjectDescription); + } + } + + public static string IndexKind + { + get + { + return Keys.GetString(Keys.IndexKind); + } + } + + public static string IndexKindDescription + { + get + { + return Keys.GetString(Keys.IndexKindDescription); + } + } + + public static string DefinedValues + { + get + { + return Keys.GetString(Keys.DefinedValues); + } + } + + public static string DefinedValuesDescription + { + get + { + return Keys.GetString(Keys.DefinedValuesDescription); + } + } + + public static string OutputList + { + get + { + return Keys.GetString(Keys.OutputList); + } + } + + public static string OutputListDescription + { + get + { + return Keys.GetString(Keys.OutputListDescription); + } + } + + public static string Warnings + { + get + { + return Keys.GetString(Keys.Warnings); + } + } + + public static string WarningsDescription + { + get + { + return Keys.GetString(Keys.WarningsDescription); + } + } + + public static string Parallel + { + get + { + return Keys.GetString(Keys.Parallel); + } + } + + public static string ParallelDescription + { + get + { + return Keys.GetString(Keys.ParallelDescription); + } + } + + public static string EstimatedNumberOfRowsPerExecution + { + get + { + return Keys.GetString(Keys.EstimatedNumberOfRowsPerExecution); + } + } + + public static string EstimatedNumberOfRowsPerExecutionDescription + { + get + { + return Keys.GetString(Keys.EstimatedNumberOfRowsPerExecutionDescription); + } + } + + public static string EstimatedNumberOfRowsForAllExecutions + { + get + { + return Keys.GetString(Keys.EstimatedNumberOfRowsForAllExecutions); + } + } + + public static string EstimatedNumberOfRowsForAllExecutionsDescription + { + get + { + return Keys.GetString(Keys.EstimatedNumberOfRowsForAllExecutionsDescription); + } + } + + public static string EstimatedRowsRead + { + get + { + return Keys.GetString(Keys.EstimatedRowsRead); + } + } + + public static string EstimatedRowsReadDescription + { + get + { + return Keys.GetString(Keys.EstimatedRowsReadDescription); + } + } + + public static string IsGraphDBTransitiveClosure + { + get + { + return Keys.GetString(Keys.IsGraphDBTransitiveClosure); + } + } + + public static string IsGraphDBTransitiveClosureDescription + { + get + { + return Keys.GetString(Keys.IsGraphDBTransitiveClosureDescription); + } + } + + public static string IsInterleavedExecuted + { + get + { + return Keys.GetString(Keys.IsInterleavedExecuted); + } + } + + public static string IsInterleavedExecutedDescription + { + get + { + return Keys.GetString(Keys.IsInterleavedExecutedDescription); + } + } + + public static string IsAdaptive + { + get + { + return Keys.GetString(Keys.IsAdaptive); + } + } + + public static string IsAdaptiveDescription + { + get + { + return Keys.GetString(Keys.IsAdaptiveDescription); + } + } + + public static string AdaptiveThresholdRows + { + get + { + return Keys.GetString(Keys.AdaptiveThresholdRows); + } + } + + public static string AdaptiveThresholdRowsDescription + { + get + { + return Keys.GetString(Keys.AdaptiveThresholdRowsDescription); + } + } + + public static string EstimatedJoinType + { + get + { + return Keys.GetString(Keys.EstimatedJoinType); + } + } + + public static string EstimatedJoinTypeDescription + { + get + { + return Keys.GetString(Keys.EstimatedJoinTypeDescription); + } + } + + public static string ActualJoinType + { + get + { + return Keys.GetString(Keys.ActualJoinType); + } + } + + public static string ActualJoinTypeDescription + { + get + { + return Keys.GetString(Keys.ActualJoinTypeDescription); + } + } + + public static string EstimatedRowSize + { + get + { + return Keys.GetString(Keys.EstimatedRowSize); + } + } + + public static string EstimatedRowSizeDescription + { + get + { + return Keys.GetString(Keys.EstimatedRowSizeDescription); + } + } + + public static string EstimatedIoCost + { + get + { + return Keys.GetString(Keys.EstimatedIoCost); + } + } + + public static string EstimatedIoCostDescription + { + get + { + return Keys.GetString(Keys.EstimatedIoCostDescription); + } + } + + public static string EstimatedCpuCost + { + get + { + return Keys.GetString(Keys.EstimatedCpuCost); + } + } + + public static string EstimatedCpuCostDescription + { + get + { + return Keys.GetString(Keys.EstimatedCpuCostDescription); + } + } + + public static string EstimatedNumberOfExecutions + { + get + { + return Keys.GetString(Keys.EstimatedNumberOfExecutions); + } + } + + public static string EstimatedNumberOfExecutionsDescription + { + get + { + return Keys.GetString(Keys.EstimatedNumberOfExecutionsDescription); + } + } + + public static string EstimatedOperatorCost + { + get + { + return Keys.GetString(Keys.EstimatedOperatorCost); + } + } + + public static string EstimatedOperatorCostDescription + { + get + { + return Keys.GetString(Keys.EstimatedOperatorCostDescription); + } + } + + public static string EstimatedSubtreeCost + { + get + { + return Keys.GetString(Keys.EstimatedSubtreeCost); + } + } + + public static string EstimatedSubtreeCostDescription + { + get + { + return Keys.GetString(Keys.EstimatedSubtreeCostDescription); + } + } + + public static string NumberOfRows + { + get + { + return Keys.GetString(Keys.NumberOfRows); + } + } + + public static string NumberOfRowsDescription + { + get + { + return Keys.GetString(Keys.NumberOfRowsDescription); + } + } + + public static string ActualRowsRead + { + get + { + return Keys.GetString(Keys.ActualRowsRead); + } + } + + public static string ActualRowsReadDescription + { + get + { + return Keys.GetString(Keys.ActualRowsReadDescription); + } + } + + public static string NumberOfBatches + { + get + { + return Keys.GetString(Keys.NumberOfBatches); + } + } + + public static string NumberOfBatchesDescription + { + get + { + return Keys.GetString(Keys.NumberOfBatchesDescription); + } + } + + public static string NumberOfExecutions + { + get + { + return Keys.GetString(Keys.NumberOfExecutions); + } + } + + public static string NumberOfExecutionsDescription + { + get + { + return Keys.GetString(Keys.NumberOfExecutionsDescription); + } + } + + public static string EstimatedDataSize + { + get + { + return Keys.GetString(Keys.EstimatedDataSize); + } + } + + public static string EstimatedDataSizeDescription + { + get + { + return Keys.GetString(Keys.EstimatedDataSizeDescription); + } + } + + public static string ParameterList + { + get + { + return Keys.GetString(Keys.ParameterList); + } + } + + public static string ParameterListDescription + { + get + { + return Keys.GetString(Keys.ParameterListDescription); + } + } + + public static string MemoryFractions + { + get + { + return Keys.GetString(Keys.MemoryFractions); + } + } + + public static string MemoryFractionsDescription + { + get + { + return Keys.GetString(Keys.MemoryFractionsDescription); + } + } + + public static string MemoryFractionsInput + { + get + { + return Keys.GetString(Keys.MemoryFractionsInput); + } + } + + public static string MemoryFractionsInputDescription + { + get + { + return Keys.GetString(Keys.MemoryFractionsInputDescription); + } + } + + public static string MemoryFractionsOutput + { + get + { + return Keys.GetString(Keys.MemoryFractionsOutput); + } + } + + public static string MemoryFractionsOutputDescription + { + get + { + return Keys.GetString(Keys.MemoryFractionsOutputDescription); + } + } + + public static string UdxName + { + get + { + return Keys.GetString(Keys.UdxName); + } + } + + public static string UdxNameDescription + { + get + { + return Keys.GetString(Keys.UdxNameDescription); + } + } + + public static string Values + { + get + { + return Keys.GetString(Keys.Values); + } + } + + public static string ValuesDescription + { + get + { + return Keys.GetString(Keys.ValuesDescription); + } + } + + public static string CachedPlanSize + { + get + { + return Keys.GetString(Keys.CachedPlanSize); + } + } + + public static string CachedPlanSizeDescription + { + get + { + return Keys.GetString(Keys.CachedPlanSizeDescription); + } + } + + public static string UsePlan + { + get + { + return Keys.GetString(Keys.UsePlan); + } + } + + public static string ContainsInlineScalarTsqlUdfs + { + get + { + return Keys.GetString(Keys.ContainsInlineScalarTsqlUdfs); + } + } + + public static string DegreeOfParallelism + { + get + { + return Keys.GetString(Keys.DegreeOfParallelism); + } + } + + public static string DegreeOfParallelismDescription + { + get + { + return Keys.GetString(Keys.DegreeOfParallelismDescription); + } + } + + public static string EffectiveDegreeOfParallelism + { + get + { + return Keys.GetString(Keys.EffectiveDegreeOfParallelism); + } + } + + public static string EffectiveDegreeOfParallelismDescription + { + get + { + return Keys.GetString(Keys.EffectiveDegreeOfParallelismDescription); + } + } + + public static string MemoryGrant + { + get + { + return Keys.GetString(Keys.MemoryGrant); + } + } + + public static string MemoryGrantDescription + { + get + { + return Keys.GetString(Keys.MemoryGrantDescription); + } + } + + public static string RemoteDestination + { + get + { + return Keys.GetString(Keys.RemoteDestination); + } + } + + public static string RemoteDestinationDescription + { + get + { + return Keys.GetString(Keys.RemoteDestinationDescription); + } + } + + public static string RemoteObject + { + get + { + return Keys.GetString(Keys.RemoteObject); + } + } + + public static string RemoteObjectDescription + { + get + { + return Keys.GetString(Keys.RemoteObjectDescription); + } + } + + public static string RemoteSource + { + get + { + return Keys.GetString(Keys.RemoteSource); + } + } + + public static string RemoteSourceDescription + { + get + { + return Keys.GetString(Keys.RemoteSourceDescription); + } + } + + public static string UsedUdxColumns + { + get + { + return Keys.GetString(Keys.UsedUdxColumns); + } + } + + public static string UsedUdxColumnsDescription + { + get + { + return Keys.GetString(Keys.UsedUdxColumnsDescription); + } + } + + public static string InnerSideJoinColumns + { + get + { + return Keys.GetString(Keys.InnerSideJoinColumns); + } + } + + public static string InnerSideJoinColumnsDescription + { + get + { + return Keys.GetString(Keys.InnerSideJoinColumnsDescription); + } + } + + public static string OuterSideJoinColumns + { + get + { + return Keys.GetString(Keys.OuterSideJoinColumns); + } + } + + public static string OuterSideJoinColumnsDescription + { + get + { + return Keys.GetString(Keys.OuterSideJoinColumnsDescription); + } + } + + public static string WhereJoinColumns + { + get + { + return Keys.GetString(Keys.WhereJoinColumns); + } + } + + public static string Residual + { + get + { + return Keys.GetString(Keys.Residual); + } + } + + public static string ResidualDescription + { + get + { + return Keys.GetString(Keys.ResidualDescription); + } + } + + public static string PassThru + { + get + { + return Keys.GetString(Keys.PassThru); + } + } + + public static string PassThruDescription + { + get + { + return Keys.GetString(Keys.PassThruDescription); + } + } + + public static string ManyToMany + { + get + { + return Keys.GetString(Keys.ManyToMany); + } + } + + public static string ManyToManyDescription + { + get + { + return Keys.GetString(Keys.ManyToManyDescription); + } + } + + public static string PartitionColumns + { + get + { + return Keys.GetString(Keys.PartitionColumns); + } + } + + public static string PartitionColumnsDescription + { + get + { + return Keys.GetString(Keys.PartitionColumnsDescription); + } + } + + public static string Ascending + { + get + { + return Keys.GetString(Keys.Ascending); + } + } + + public static string Descending + { + get + { + return Keys.GetString(Keys.Descending); + } + } + + public static string HashKeys + { + get + { + return Keys.GetString(Keys.HashKeys); + } + } + + public static string HashKeysDescription + { + get + { + return Keys.GetString(Keys.HashKeysDescription); + } + } + + public static string ProbeColumn + { + get + { + return Keys.GetString(Keys.ProbeColumn); + } + } + + public static string ProbeColumnDescription + { + get + { + return Keys.GetString(Keys.ProbeColumnDescription); + } + } + + public static string PartitioningType + { + get + { + return Keys.GetString(Keys.PartitioningType); + } + } + + public static string PartitioningTypeDescription + { + get + { + return Keys.GetString(Keys.PartitioningTypeDescription); + } + } + + public static string GroupBy + { + get + { + return Keys.GetString(Keys.GroupBy); + } + } + + public static string GroupByDescription + { + get + { + return Keys.GetString(Keys.GroupByDescription); + } + } + + public static string GroupingSets + { + get + { + return Keys.GetString(Keys.GroupingSets); + } + } + + public static string GroupingSetsDescription + { + get + { + return Keys.GetString(Keys.GroupingSetsDescription); + } + } + + public static string SegmentColumn + { + get + { + return Keys.GetString(Keys.SegmentColumn); + } + } + + public static string SegmentColumnDescription + { + get + { + return Keys.GetString(Keys.SegmentColumnDescription); + } + } + + public static string RankColumns + { + get + { + return Keys.GetString(Keys.RankColumns); + } + } + + public static string RankColumnsDescription + { + get + { + return Keys.GetString(Keys.RankColumnsDescription); + } + } + + public static string Predicate + { + get + { + return Keys.GetString(Keys.Predicate); + } + } + + public static string PredicateDescription + { + get + { + return Keys.GetString(Keys.PredicateDescription); + } + } + + public static string OuterReferences + { + get + { + return Keys.GetString(Keys.OuterReferences); + } + } + + public static string OuterReferencesDescription + { + get + { + return Keys.GetString(Keys.OuterReferencesDescription); + } + } + + public static string ScalarOperator + { + get + { + return Keys.GetString(Keys.ScalarOperator); + } + } + + public static string ActionColumn + { + get + { + return Keys.GetString(Keys.ActionColumn); + } + } + + public static string ActionColumnDescription + { + get + { + return Keys.GetString(Keys.ActionColumnDescription); + } + } + + public static string OriginalActionColumn + { + get + { + return Keys.GetString(Keys.OriginalActionColumn); + } + } + + public static string OriginalActionColumnDescription + { + get + { + return Keys.GetString(Keys.OriginalActionColumnDescription); + } + } + + public static string Rows + { + get + { + return Keys.GetString(Keys.Rows); + } + } + + public static string RowsDescription + { + get + { + return Keys.GetString(Keys.RowsDescription); + } + } + + public static string SeekPredicate + { + get + { + return Keys.GetString(Keys.SeekPredicate); + } + } + + public static string SeekPredicateDescription + { + get + { + return Keys.GetString(Keys.SeekPredicateDescription); + } + } + + public static string Partitioned + { + get + { + return Keys.GetString(Keys.Partitioned); + } + } + + public static string PartitionedDescription + { + get + { + return Keys.GetString(Keys.PartitionedDescription); + } + } + + public static string SeekKeys + { + get + { + return Keys.GetString(Keys.SeekKeys); + } + } + + public static string SeekKeysDescription + { + get + { + return Keys.GetString(Keys.SeekKeysDescription); + } + } + + public static string PartitionsAccessed + { + get + { + return Keys.GetString(Keys.PartitionsAccessed); + } + } + + public static string PartitionCount + { + get + { + return Keys.GetString(Keys.PartitionCount); + } + } + + public static string TieColumns + { + get + { + return Keys.GetString(Keys.TieColumns); + } + } + + public static string TieColumnsDescription + { + get + { + return Keys.GetString(Keys.TieColumnsDescription); + } + } + + public static string IsPercent + { + get + { + return Keys.GetString(Keys.IsPercent); + } + } + + public static string IsPercentDescription + { + get + { + return Keys.GetString(Keys.IsPercentDescription); + } + } + + public static string WithTies + { + get + { + return Keys.GetString(Keys.WithTies); + } + } + + public static string WithTiesDescription + { + get + { + return Keys.GetString(Keys.WithTiesDescription); + } + } + + public static string PartitionId + { + get + { + return Keys.GetString(Keys.PartitionId); + } + } + + public static string PartitionIdDescription + { + get + { + return Keys.GetString(Keys.PartitionIdDescription); + } + } + + public static string Ordered + { + get + { + return Keys.GetString(Keys.Ordered); + } + } + + public static string OrderedDescription + { + get + { + return Keys.GetString(Keys.OrderedDescription); + } + } + + public static string ScanDirection + { + get + { + return Keys.GetString(Keys.ScanDirection); + } + } + + public static string ScanDirectionDescription + { + get + { + return Keys.GetString(Keys.ScanDirectionDescription); + } + } + + public static string ForcedIndex + { + get + { + return Keys.GetString(Keys.ForcedIndex); + } + } + + public static string ForcedIndexDescription + { + get + { + return Keys.GetString(Keys.ForcedIndexDescription); + } + } + + public static string SetPredicate + { + get + { + return Keys.GetString(Keys.SetPredicate); + } + } + + public static string SetPredicateDescription + { + get + { + return Keys.GetString(Keys.SetPredicateDescription); + } + } + + public static string TopExpression + { + get + { + return Keys.GetString(Keys.TopExpression); + } + } + + public static string TopExpressionDescription + { + get + { + return Keys.GetString(Keys.TopExpressionDescription); + } + } + + public static string HashKeysBuild + { + get + { + return Keys.GetString(Keys.HashKeysBuild); + } + } + + public static string HashKeysBuildDescription + { + get + { + return Keys.GetString(Keys.HashKeysBuildDescription); + } + } + + public static string HashKeysProbe + { + get + { + return Keys.GetString(Keys.HashKeysProbe); + } + } + + public static string HashKeysProbeDescription + { + get + { + return Keys.GetString(Keys.HashKeysProbeDescription); + } + } + + public static string BuildResidual + { + get + { + return Keys.GetString(Keys.BuildResidual); + } + } + + public static string BuildResidualDescription + { + get + { + return Keys.GetString(Keys.BuildResidualDescription); + } + } + + public static string ProbeResidual + { + get + { + return Keys.GetString(Keys.ProbeResidual); + } + } + + public static string ProbeResidualDescription + { + get + { + return Keys.GetString(Keys.ProbeResidualDescription); + } + } + + public static string SeekPredicates + { + get + { + return Keys.GetString(Keys.SeekPredicates); + } + } + + public static string SeekPredicatesDescription + { + get + { + return Keys.GetString(Keys.SeekPredicatesDescription); + } + } + + public static string SetOptions + { + get + { + return Keys.GetString(Keys.SetOptions); + } + } + + public static string SetOptionsDescription + { + get + { + return Keys.GetString(Keys.SetOptionsDescription); + } + } + + public static string OptimizationLevel + { + get + { + return Keys.GetString(Keys.OptimizationLevel); + } + } + + public static string OptimizationLevelDescription + { + get + { + return Keys.GetString(Keys.OptimizationLevelDescription); + } + } + + public static string StatementOptmEarlyAbortReason + { + get + { + return Keys.GetString(Keys.StatementOptmEarlyAbortReason); + } + } + + public static string TimeOut + { + get + { + return Keys.GetString(Keys.TimeOut); + } + } + + public static string MemoryLimitExceeded + { + get + { + return Keys.GetString(Keys.MemoryLimitExceeded); + } + } + + public static string GoodEnoughPlanFound + { + get + { + return Keys.GetString(Keys.GoodEnoughPlanFound); + } + } + + public static string EstimatedRebinds + { + get + { + return Keys.GetString(Keys.EstimatedRebinds); + } + } + + public static string EstimatedRebindsDescription + { + get + { + return Keys.GetString(Keys.EstimatedRebindsDescription); + } + } + + public static string EstimatedRewinds + { + get + { + return Keys.GetString(Keys.EstimatedRewinds); + } + } + + public static string EstimatedRewindsDescription + { + get + { + return Keys.GetString(Keys.EstimatedRewindsDescription); + } + } + + public static string ActualLocallyAggregatedRows + { + get + { + return Keys.GetString(Keys.ActualLocallyAggregatedRows); + } + } + + public static string ActualLocallyAggregatedRowsDescription + { + get + { + return Keys.GetString(Keys.ActualLocallyAggregatedRowsDescription); + } + } + + public static string ActualRebinds + { + get + { + return Keys.GetString(Keys.ActualRebinds); + } + } + + public static string ActualRebindsDescription + { + get + { + return Keys.GetString(Keys.ActualRebindsDescription); + } + } + + public static string ActualRewinds + { + get + { + return Keys.GetString(Keys.ActualRewinds); + } + } + + public static string ActualRewindsDescription + { + get + { + return Keys.GetString(Keys.ActualRewindsDescription); + } + } + + public static string ActualIOStatistics + { + get + { + return Keys.GetString(Keys.ActualIOStatistics); + } + } + + public static string ActualIOStatisticsDescription + { + get + { + return Keys.GetString(Keys.ActualIOStatisticsDescription); + } + } + + public static string ActualTimeStatistics + { + get + { + return Keys.GetString(Keys.ActualTimeStatistics); + } + } + + public static string ActualTimeStatisticsDescription + { + get + { + return Keys.GetString(Keys.ActualTimeStatisticsDescription); + } + } + + public static string ActualElapsedms + { + get + { + return Keys.GetString(Keys.ActualElapsedms); + } + } + + public static string ActualElapsedmsDescription + { + get + { + return Keys.GetString(Keys.ActualElapsedmsDescription); + } + } + + public static string ActualCPUms + { + get + { + return Keys.GetString(Keys.ActualCPUms); + } + } + + public static string ActualCPUmsDescription + { + get + { + return Keys.GetString(Keys.ActualCPUmsDescription); + } + } + + public static string ActualScans + { + get + { + return Keys.GetString(Keys.ActualScans); + } + } + + public static string ActualScansDescription + { + get + { + return Keys.GetString(Keys.ActualScansDescription); + } + } + + public static string ActualLogicalReads + { + get + { + return Keys.GetString(Keys.ActualLogicalReads); + } + } + + public static string ActualLogicalReadsDescription + { + get + { + return Keys.GetString(Keys.ActualLogicalReadsDescription); + } + } + + public static string ActualPhysicalReads + { + get + { + return Keys.GetString(Keys.ActualPhysicalReads); + } + } + + public static string ActualPhysicalReadsDescription + { + get + { + return Keys.GetString(Keys.ActualPhysicalReadsDescription); + } + } + + public static string ActualPageServerReads + { + get + { + return Keys.GetString(Keys.ActualPageServerReads); + } + } + + public static string ActualPageServerReadsDescription + { + get + { + return Keys.GetString(Keys.ActualPageServerReadsDescription); + } + } + + public static string ActualReadAheads + { + get + { + return Keys.GetString(Keys.ActualReadAheads); + } + } + + public static string ActualReadAheadsDescription + { + get + { + return Keys.GetString(Keys.ActualReadAheadsDescription); + } + } + + public static string ActualPageServerReadAheads + { + get + { + return Keys.GetString(Keys.ActualPageServerReadAheads); + } + } + + public static string ActualPageServerReadAheadsDescription + { + get + { + return Keys.GetString(Keys.ActualPageServerReadAheadsDescription); + } + } + + public static string ActualLobLogicalReads + { + get + { + return Keys.GetString(Keys.ActualLobLogicalReads); + } + } + + public static string ActualLobLogicalReadsDescription + { + get + { + return Keys.GetString(Keys.ActualLobLogicalReadsDescription); + } + } + + public static string ActualLobPhysicalReads + { + get + { + return Keys.GetString(Keys.ActualLobPhysicalReads); + } + } + + public static string ActualLobPhysicalReadsDescription + { + get + { + return Keys.GetString(Keys.ActualLobPhysicalReadsDescription); + } + } + + public static string ActualLobPageServerReads + { + get + { + return Keys.GetString(Keys.ActualLobPageServerReads); + } + } + + public static string ActualLobPageServerReadsDescription + { + get + { + return Keys.GetString(Keys.ActualLobPageServerReadsDescription); + } + } + + public static string ActualLobReadAheads + { + get + { + return Keys.GetString(Keys.ActualLobReadAheads); + } + } + + public static string ActualLobReadAheadsDescription + { + get + { + return Keys.GetString(Keys.ActualLobReadAheadsDescription); + } + } + + public static string ActualLobPageServerReadAheads + { + get + { + return Keys.GetString(Keys.ActualLobPageServerReadAheads); + } + } + + public static string ActualLobPageServerReadAheadsDescription + { + get + { + return Keys.GetString(Keys.ActualLobPageServerReadAheadsDescription); + } + } + + public static string ActualMemoryGrantStats + { + get + { + return Keys.GetString(Keys.ActualMemoryGrantStats); + } + } + + public static string HpcRowCount + { + get + { + return Keys.GetString(Keys.HpcRowCount); + } + } + + public static string HpcRowCountDescription + { + get + { + return Keys.GetString(Keys.HpcRowCountDescription); + } + } + + public static string HpcKernelElapsedUs + { + get + { + return Keys.GetString(Keys.HpcKernelElapsedUs); + } + } + + public static string HpcKernelElapsedUsDescription + { + get + { + return Keys.GetString(Keys.HpcKernelElapsedUsDescription); + } + } + + public static string HpcHostToDeviceBytes + { + get + { + return Keys.GetString(Keys.HpcHostToDeviceBytes); + } + } + + public static string HpcHostToDeviceBytesDescription + { + get + { + return Keys.GetString(Keys.HpcHostToDeviceBytesDescription); + } + } + + public static string HpcDeviceToHostBytes + { + get + { + return Keys.GetString(Keys.HpcDeviceToHostBytes); + } + } + + public static string HpcDeviceToHostBytesDescription + { + get + { + return Keys.GetString(Keys.HpcDeviceToHostBytesDescription); + } + } + + public static string InputMemoryGrant + { + get + { + return Keys.GetString(Keys.InputMemoryGrant); + } + } + + public static string OutputMemoryGrant + { + get + { + return Keys.GetString(Keys.OutputMemoryGrant); + } + } + + public static string UsedMemoryGrant + { + get + { + return Keys.GetString(Keys.UsedMemoryGrant); + } + } + + public static string Distinct + { + get + { + return Keys.GetString(Keys.Distinct); + } + } + + public static string DistinctDescription + { + get + { + return Keys.GetString(Keys.DistinctDescription); + } + } + + public static string OrderBy + { + get + { + return Keys.GetString(Keys.OrderBy); + } + } + + public static string OrderByDescription + { + get + { + return Keys.GetString(Keys.OrderByDescription); + } + } + + public static string SpillOccurredDisplayString + { + get + { + return Keys.GetString(Keys.SpillOccurredDisplayString); + } + } + + public static string ColumnsWithNoStatistics + { + get + { + return Keys.GetString(Keys.ColumnsWithNoStatistics); + } + } + + public static string ColumnsWithNoStatisticsDescription + { + get + { + return Keys.GetString(Keys.ColumnsWithNoStatisticsDescription); + } + } + + public static string NoJoinPredicate + { + get + { + return Keys.GetString(Keys.NoJoinPredicate); + } + } + + public static string NoJoinPredicateDescription + { + get + { + return Keys.GetString(Keys.NoJoinPredicateDescription); + } + } + + public static string SpillToTempDbOld + { + get + { + return Keys.GetString(Keys.SpillToTempDbOld); + } + } + + public static string SpillToTempDb + { + get + { + return Keys.GetString(Keys.SpillToTempDb); + } + } + + public static string SpillToTempDbDescription + { + get + { + return Keys.GetString(Keys.SpillToTempDbDescription); + } + } + + public static string SortSpillDetails + { + get + { + return Keys.GetString(Keys.SortSpillDetails); + } + } + + public static string SortSpillDetailsDescription + { + get + { + return Keys.GetString(Keys.SortSpillDetailsDescription); + } + } + + public static string HashSpillDetails + { + get + { + return Keys.GetString(Keys.HashSpillDetails); + } + } + + public static string HashSpillDetailsDescription + { + get + { + return Keys.GetString(Keys.HashSpillDetailsDescription); + } + } + + public static string FullUpdateForOnlineIndexBuild + { + get + { + return Keys.GetString(Keys.FullUpdateForOnlineIndexBuild); + } + } + + public static string FullUpdateForOnlineIndexBuildDescription + { + get + { + return Keys.GetString(Keys.FullUpdateForOnlineIndexBuildDescription); + } + } + + public static string Wait + { + get + { + return Keys.GetString(Keys.Wait); + } + } + + public static string WaitDescription + { + get + { + return Keys.GetString(Keys.WaitDescription); + } + } + + public static string PlanAffectingConvert + { + get + { + return Keys.GetString(Keys.PlanAffectingConvert); + } + } + + public static string PlanAffectingConvertDescription + { + get + { + return Keys.GetString(Keys.PlanAffectingConvertDescription); + } + } + + public static string MemoryGrantWarning + { + get + { + return Keys.GetString(Keys.MemoryGrantWarning); + } + } + + public static string MemoryGrantWarningDescription + { + get + { + return Keys.GetString(Keys.MemoryGrantWarningDescription); + } + } + + public static string StartupExpression + { + get + { + return Keys.GetString(Keys.StartupExpression); + } + } + + public static string StartupExpressionDescription + { + get + { + return Keys.GetString(Keys.StartupExpressionDescription); + } + } + + public static string StartupExpressionPredicate + { + get + { + return Keys.GetString(Keys.StartupExpressionPredicate); + } + } + + public static string Query + { + get + { + return Keys.GetString(Keys.Query); + } + } + + public static string Stack + { + get + { + return Keys.GetString(Keys.Stack); + } + } + + public static string RowCount + { + get + { + return Keys.GetString(Keys.RowCount); + } + } + + public static string Optimized + { + get + { + return Keys.GetString(Keys.Optimized); + } + } + + public static string WithPrefetch + { + get + { + return Keys.GetString(Keys.WithPrefetch); + } + } + + public static string Prefix + { + get + { + return Keys.GetString(Keys.Prefix); + } + } + + public static string StartRange + { + get + { + return Keys.GetString(Keys.StartRange); + } + } + + public static string StartRangeDescription + { + get + { + return Keys.GetString(Keys.StartRangeDescription); + } + } + + public static string EndRange + { + get + { + return Keys.GetString(Keys.EndRange); + } + } + + public static string EndRangeDescription + { + get + { + return Keys.GetString(Keys.EndRangeDescription); + } + } + + public static string RangeColumns + { + get + { + return Keys.GetString(Keys.RangeColumns); + } + } + + public static string RangeExpressions + { + get + { + return Keys.GetString(Keys.RangeExpressions); + } + } + + public static string ScanType + { + get + { + return Keys.GetString(Keys.ScanType); + } + } + + public static string ColumnReference + { + get + { + return Keys.GetString(Keys.ColumnReference); + } + } + + public static string ObjectServer + { + get + { + return Keys.GetString(Keys.ObjectServer); + } + } + + public static string ObjectServerDescription + { + get + { + return Keys.GetString(Keys.ObjectServerDescription); + } + } + + public static string ObjectDatabase + { + get + { + return Keys.GetString(Keys.ObjectDatabase); + } + } + + public static string ObjectDatabaseDescription + { + get + { + return Keys.GetString(Keys.ObjectDatabaseDescription); + } + } + + public static string ObjectIndex + { + get + { + return Keys.GetString(Keys.ObjectIndex); + } + } + + public static string ObjectIndexDescription + { + get + { + return Keys.GetString(Keys.ObjectIndexDescription); + } + } + + public static string ObjectSchema + { + get + { + return Keys.GetString(Keys.ObjectSchema); + } + } + + public static string ObjectSchemaDescription + { + get + { + return Keys.GetString(Keys.ObjectSchemaDescription); + } + } + + public static string ObjectTable + { + get + { + return Keys.GetString(Keys.ObjectTable); + } + } + + public static string ObjectTableDescription + { + get + { + return Keys.GetString(Keys.ObjectTableDescription); + } + } + + public static string ObjectAlias + { + get + { + return Keys.GetString(Keys.ObjectAlias); + } + } + + public static string ObjectAliasDescription + { + get + { + return Keys.GetString(Keys.ObjectAliasDescription); + } + } + + public static string ObjectColumn + { + get + { + return Keys.GetString(Keys.ObjectColumn); + } + } + + public static string ObjectColumnDescription + { + get + { + return Keys.GetString(Keys.ObjectColumnDescription); + } + } + + public static string ObjectComputedColumn + { + get + { + return Keys.GetString(Keys.ObjectComputedColumn); + } + } + + public static string ObjectComputedColumnDescription + { + get + { + return Keys.GetString(Keys.ObjectComputedColumnDescription); + } + } + + public static string ParameterDataType + { + get + { + return Keys.GetString(Keys.ParameterDataType); + } + } + + public static string ParameterCompiledValue + { + get + { + return Keys.GetString(Keys.ParameterCompiledValue); + } + } + + public static string ParameterRuntimeValue + { + get + { + return Keys.GetString(Keys.ParameterRuntimeValue); + } + } + + public static string CursorPlan + { + get + { + return Keys.GetString(Keys.CursorPlan); + } + } + + public static string CursorOperation + { + get + { + return Keys.GetString(Keys.CursorOperation); + } + } + + public static string CursorName + { + get + { + return Keys.GetString(Keys.CursorName); + } + } + + public static string CursorActualType + { + get + { + return Keys.GetString(Keys.CursorActualType); + } + } + + public static string CursorRequestedType + { + get + { + return Keys.GetString(Keys.CursorRequestedType); + } + } + + public static string CursorConcurrency + { + get + { + return Keys.GetString(Keys.CursorConcurrency); + } + } + + public static string ForwardOnly + { + get + { + return Keys.GetString(Keys.ForwardOnly); + } + } + + public static string QueryPlan + { + get + { + return Keys.GetString(Keys.QueryPlan); + } + } + + public static string OperationType + { + get + { + return Keys.GetString(Keys.OperationType); + } + } + + public static string NodeId + { + get + { + return Keys.GetString(Keys.NodeId); + } + } + + public static string PrimaryNodeId + { + get + { + return Keys.GetString(Keys.PrimaryNodeId); + } + } + + public static string InternalInfo + { + get + { + return Keys.GetString(Keys.InternalInfo); + } + } + + public static string ForeignKeyReferencesCount + { + get + { + return Keys.GetString(Keys.ForeignKeyReferencesCount); + } + } + + public static string NoMatchingIndexCount + { + get + { + return Keys.GetString(Keys.NoMatchingIndexCount); + } + } + + public static string PartialMatchingIndexCount + { + get + { + return Keys.GetString(Keys.PartialMatchingIndexCount); + } + } + + public static string LogicalOpCollapse + { + get + { + return Keys.GetString(Keys.LogicalOpCollapse); + } + } + + public static string LogicalOpConcatenation + { + get + { + return Keys.GetString(Keys.LogicalOpConcatenation); + } + } + + public static string LogicalOpConstantScan + { + get + { + return Keys.GetString(Keys.LogicalOpConstantScan); + } + } + + public static string LogicalOpGatherStreams + { + get + { + return Keys.GetString(Keys.LogicalOpGatherStreams); + } + } + + public static string LogicalOpRepartitionStreams + { + get + { + return Keys.GetString(Keys.LogicalOpRepartitionStreams); + } + } + + public static string LogicalOpDistributeStreams + { + get + { + return Keys.GetString(Keys.LogicalOpDistributeStreams); + } + } + + public static string LogicalOpFilter + { + get + { + return Keys.GetString(Keys.LogicalOpFilter); + } + } + + public static string LogicalOpAssert + { + get + { + return Keys.GetString(Keys.LogicalOpAssert); + } + } + + public static string LogicalOpLogRowScan + { + get + { + return Keys.GetString(Keys.LogicalOpLogRowScan); + } + } + + public static string LogicalOpPrint + { + get + { + return Keys.GetString(Keys.LogicalOpPrint); + } + } + + public static string LogicalOpComputeScalar + { + get + { + return Keys.GetString(Keys.LogicalOpComputeScalar); + } + } + + public static string LogicalOpMergeInterval + { + get + { + return Keys.GetString(Keys.LogicalOpMergeInterval); + } + } + + public static string LogicalOpRank + { + get + { + return Keys.GetString(Keys.LogicalOpRank); + } + } + + public static string LogicalOpSegment + { + get + { + return Keys.GetString(Keys.LogicalOpSegment); + } + } + + public static string LogicalOpSequence + { + get + { + return Keys.GetString(Keys.LogicalOpSequence); + } + } + + public static string LogicalOpSplit + { + get + { + return Keys.GetString(Keys.LogicalOpSplit); + } + } + + public static string LogicalOpAggregate + { + get + { + return Keys.GetString(Keys.LogicalOpAggregate); + } + } + + public static string LogicalOpTableScan + { + get + { + return Keys.GetString(Keys.LogicalOpTableScan); + } + } + + public static string LogicalOpClusteredIndexScan + { + get + { + return Keys.GetString(Keys.LogicalOpClusteredIndexScan); + } + } + + public static string LogicalOpClusteredIndexSeek + { + get + { + return Keys.GetString(Keys.LogicalOpClusteredIndexSeek); + } + } + + public static string LogicalOpDeletedScan + { + get + { + return Keys.GetString(Keys.LogicalOpDeletedScan); + } + } + + public static string LogicalOpInsertedScan + { + get + { + return Keys.GetString(Keys.LogicalOpInsertedScan); + } + } + + public static string LogicalOpParameterTableScan + { + get + { + return Keys.GetString(Keys.LogicalOpParameterTableScan); + } + } + + public static string LogicalOpPut + { + get + { + return Keys.GetString(Keys.LogicalOpPut); + } + } + + public static string LogicalOpIndexScan + { + get + { + return Keys.GetString(Keys.LogicalOpIndexScan); + } + } + + public static string LogicalOpIndexSeek + { + get + { + return Keys.GetString(Keys.LogicalOpIndexSeek); + } + } + + public static string LogicalOpRemoteScan + { + get + { + return Keys.GetString(Keys.LogicalOpRemoteScan); + } + } + + public static string LogicalOpRemoteIndexScan + { + get + { + return Keys.GetString(Keys.LogicalOpRemoteIndexScan); + } + } + + public static string LogicalOpRemoteIndexSeek + { + get + { + return Keys.GetString(Keys.LogicalOpRemoteIndexSeek); + } + } + + public static string LogicalOpRemoteQuery + { + get + { + return Keys.GetString(Keys.LogicalOpRemoteQuery); + } + } + + public static string LogicalOpRemoteInsert + { + get + { + return Keys.GetString(Keys.LogicalOpRemoteInsert); + } + } + + public static string LogicalOpRemoteUpdate + { + get + { + return Keys.GetString(Keys.LogicalOpRemoteUpdate); + } + } + + public static string LogicalOpRemoteDelete + { + get + { + return Keys.GetString(Keys.LogicalOpRemoteDelete); + } + } + + public static string LogicalOpClusteredUpdate + { + get + { + return Keys.GetString(Keys.LogicalOpClusteredUpdate); + } + } + + public static string LogicalOpDistinctSort + { + get + { + return Keys.GetString(Keys.LogicalOpDistinctSort); + } + } + + public static string LogicalOpSort + { + get + { + return Keys.GetString(Keys.LogicalOpSort); + } + } + + public static string LogicalOpTopNSort + { + get + { + return Keys.GetString(Keys.LogicalOpTopNSort); + } + } + + public static string LogicalOpEagerSpool + { + get + { + return Keys.GetString(Keys.LogicalOpEagerSpool); + } + } + + public static string LogicalOpLazySpool + { + get + { + return Keys.GetString(Keys.LogicalOpLazySpool); + } + } + + public static string LogicalOpUpdate + { + get + { + return Keys.GetString(Keys.LogicalOpUpdate); + } + } + + public static string LogicalOpInsert + { + get + { + return Keys.GetString(Keys.LogicalOpInsert); + } + } + + public static string LogicalOpDelete + { + get + { + return Keys.GetString(Keys.LogicalOpDelete); + } + } + + public static string LogicalOpMerge + { + get + { + return Keys.GetString(Keys.LogicalOpMerge); + } + } + + public static string LogicalOpTop + { + get + { + return Keys.GetString(Keys.LogicalOpTop); + } + } + + public static string LogicalOpDistinct + { + get + { + return Keys.GetString(Keys.LogicalOpDistinct); + } + } + + public static string LogicalOpFlowDistinct + { + get + { + return Keys.GetString(Keys.LogicalOpFlowDistinct); + } + } + + public static string LogicalOpPartialAggregate + { + get + { + return Keys.GetString(Keys.LogicalOpPartialAggregate); + } + } + + public static string LogicalOpInnerApply + { + get + { + return Keys.GetString(Keys.LogicalOpInnerApply); + } + } + + public static string LogicalOpInnerJoin + { + get + { + return Keys.GetString(Keys.LogicalOpInnerJoin); + } + } + + public static string LogicalOpLeftAntiSemiApply + { + get + { + return Keys.GetString(Keys.LogicalOpLeftAntiSemiApply); + } + } + + public static string LogicalOpLeftSemiApply + { + get + { + return Keys.GetString(Keys.LogicalOpLeftSemiApply); + } + } + + public static string LogicalOpLeftOuterApply + { + get + { + return Keys.GetString(Keys.LogicalOpLeftOuterApply); + } + } + + public static string LogicalOpLeftOuterJoin + { + get + { + return Keys.GetString(Keys.LogicalOpLeftOuterJoin); + } + } + + public static string LogicalOpRightOuterJoin + { + get + { + return Keys.GetString(Keys.LogicalOpRightOuterJoin); + } + } + + public static string LogicalOpFullOuterJoin + { + get + { + return Keys.GetString(Keys.LogicalOpFullOuterJoin); + } + } + + public static string LogicalOpLeftSemiJoin + { + get + { + return Keys.GetString(Keys.LogicalOpLeftSemiJoin); + } + } + + public static string LogicalOpLeftAntiSemiJoin + { + get + { + return Keys.GetString(Keys.LogicalOpLeftAntiSemiJoin); + } + } + + public static string LogicalOpRightSemiJoin + { + get + { + return Keys.GetString(Keys.LogicalOpRightSemiJoin); + } + } + + public static string LogicalOpRightAntiSemiJoin + { + get + { + return Keys.GetString(Keys.LogicalOpRightAntiSemiJoin); + } + } + + public static string LogicalOpIntersect + { + get + { + return Keys.GetString(Keys.LogicalOpIntersect); + } + } + + public static string LogicalOpIntersectAll + { + get + { + return Keys.GetString(Keys.LogicalOpIntersectAll); + } + } + + public static string LogicalOpUnion + { + get + { + return Keys.GetString(Keys.LogicalOpUnion); + } + } + + public static string LogicalOpLeftDiff + { + get + { + return Keys.GetString(Keys.LogicalOpLeftDiff); + } + } + + public static string LogicalOpLeftDiffAll + { + get + { + return Keys.GetString(Keys.LogicalOpLeftDiffAll); + } + } + + public static string LogicalOpRightDiff + { + get + { + return Keys.GetString(Keys.LogicalOpRightDiff); + } + } + + public static string LogicalOpRightDiffAll + { + get + { + return Keys.GetString(Keys.LogicalOpRightDiffAll); + } + } + + public static string LogicalOpAntiDiff + { + get + { + return Keys.GetString(Keys.LogicalOpAntiDiff); + } + } + + public static string LogicalOpCrossJoin + { + get + { + return Keys.GetString(Keys.LogicalOpCrossJoin); + } + } + + public static string LogicalOpBitmapCreate + { + get + { + return Keys.GetString(Keys.LogicalOpBitmapCreate); + } + } + + public static string LogicalOpUDX + { + get + { + return Keys.GetString(Keys.LogicalOpUDX); + } + } + + public static string LogicalOpWindow + { + get + { + return Keys.GetString(Keys.LogicalOpWindow); + } + } + + public static string LogicalOpSwitch + { + get + { + return Keys.GetString(Keys.LogicalOpSwitch); + } + } + + public static string LogicalOpMergeStats + { + get + { + return Keys.GetString(Keys.LogicalOpMergeStats); + } + } + + public static string LogicalOpLocalStats + { + get + { + return Keys.GetString(Keys.LogicalOpLocalStats); + } + } + + public static string LogicalOpTableValuedFunction + { + get + { + return Keys.GetString(Keys.LogicalOpTableValuedFunction); + } + } + + public static string LogicalOpBatchHashTableBuild + { + get + { + return Keys.GetString(Keys.LogicalOpBatchHashTableBuild); + } + } + + public static string LogicalOpForeignKeyReferencesCheck + { + get + { + return Keys.GetString(Keys.LogicalOpForeignKeyReferencesCheck); + } + } + + public static string LogicalOpRIDLookup + { + get + { + return Keys.GetString(Keys.LogicalOpRIDLookup); + } + } + + public static string StoredProc + { + get + { + return Keys.GetString(Keys.StoredProc); + } + } + + public static string Udf + { + get + { + return Keys.GetString(Keys.Udf); + } + } + + public static string ProcName + { + get + { + return Keys.GetString(Keys.ProcName); + } + } + + public static string Storage + { + get + { + return Keys.GetString(Keys.Storage); + } + } + + public static string StorageDesc + { + get + { + return Keys.GetString(Keys.StorageDesc); + } + } + + public static string ActualExecMode + { + get + { + return Keys.GetString(Keys.ActualExecMode); + } + } + + public static string ActualExecModeDesc + { + get + { + return Keys.GetString(Keys.ActualExecModeDesc); + } + } + + public static string EstimatedExecMode + { + get + { + return Keys.GetString(Keys.EstimatedExecMode); + } + } + + public static string EstimatedExecModeDesc + { + get + { + return Keys.GetString(Keys.EstimatedExecModeDesc); + } + } + + public static string RemoteDataAccess + { + get + { + return Keys.GetString(Keys.RemoteDataAccess); + } + } + + public static string RemoteDataAccessDescription + { + get + { + return Keys.GetString(Keys.RemoteDataAccessDescription); + } + } + + public static string CloneAccessScope + { + get + { + return Keys.GetString(Keys.CloneAccessScope); + } + } + + public static string CloneAccessScopeDescription + { + get + { + return Keys.GetString(Keys.CloneAccessScopeDescription); + } + } + + public static string PrimaryClones + { + get + { + return Keys.GetString(Keys.PrimaryClones); + } + } + + public static string SecondaryClones + { + get + { + return Keys.GetString(Keys.SecondaryClones); + } + } + + public static string BothClones + { + get + { + return Keys.GetString(Keys.BothClones); + } + } + + public static string EitherClones + { + get + { + return Keys.GetString(Keys.EitherClones); + } + } + + public static string ExactMatchClones + { + get + { + return Keys.GetString(Keys.ExactMatchClones); + } + } + + public static string Remoting + { + get + { + return Keys.GetString(Keys.Remoting); + } + } + + public static string RemotingDescription + { + get + { + return Keys.GetString(Keys.RemotingDescription); + } + } + + public static string Activation + { + get + { + return Keys.GetString(Keys.Activation); + } + } + + public static string BrickRouting + { + get + { + return Keys.GetString(Keys.BrickRouting); + } + } + + public static string FragmentIdColumn + { + get + { + return Keys.GetString(Keys.FragmentIdColumn); + } + } + + public static string EditQueryText + { + get + { + return Keys.GetString(Keys.EditQueryText); + } + } + + public static string UnknownShowPlanSource + { + get + { + return Keys.GetString(Keys.UnknownShowPlanSource); + } + } + + public static string SavePlanFilter + { + get + { + return Keys.GetString(Keys.SavePlanFilter); + } + } + + public static string NoXmlPlanData + { + get + { + return Keys.GetString(Keys.NoXmlPlanData); + } + } + + public static string PerThreadCounterDescription + { + get + { + return Keys.GetString(Keys.PerThreadCounterDescription); + } + } + + public static string RuntimeCounterThreadAll + { + get + { + return Keys.GetString(Keys.RuntimeCounterThreadAll); + } + } + + public static string ConnectionPropertiesLabel + { + get + { + return Keys.GetString(Keys.ConnectionPropertiesLabel); + } + } + + public static string UnknownAssignType + { + get + { + return Keys.GetString(Keys.UnknownAssignType); + } + } + + public static string MessageBoxCaption + { + get + { + return Keys.GetString(Keys.MessageBoxCaption); + } + } + + public static string UnknownNodeType + { + get + { + return Keys.GetString(Keys.UnknownNodeType); + } + } + + public static string UnknownStatementType + { + get + { + return Keys.GetString(Keys.UnknownStatementType); + } + } + + public static string RollupInfo + { + get + { + return Keys.GetString(Keys.RollupInfo); + } + } + + public static string RollupInfoDescription + { + get + { + return Keys.GetString(Keys.RollupInfoDescription); + } + } + + public static string HighestLevel + { + get + { + return Keys.GetString(Keys.HighestLevel); + } + } + + public static string HighestLevelDescription + { + get + { + return Keys.GetString(Keys.HighestLevelDescription); + } + } + + public static string RollupLevel + { + get + { + return Keys.GetString(Keys.RollupLevel); + } + } + + public static string RollupLevelDescription + { + get + { + return Keys.GetString(Keys.RollupLevelDescription); + } + } + + public static string Level + { + get + { + return Keys.GetString(Keys.Level); + } + } + + public static string LevelDescription + { + get + { + return Keys.GetString(Keys.LevelDescription); + } + } + + public static string Unknown + { + get + { + return Keys.GetString(Keys.Unknown); + } + } + + public static string UnknownDescription + { + get + { + return Keys.GetString(Keys.UnknownDescription); + } + } + + public static string Result + { + get + { + return Keys.GetString(Keys.Result); + } + } + + public static string ResultDescription + { + get + { + return Keys.GetString(Keys.ResultDescription); + } + } + + public static string Collapse + { + get + { + return Keys.GetString(Keys.Collapse); + } + } + + public static string CollapseDescription + { + get + { + return Keys.GetString(Keys.CollapseDescription); + } + } + + public static string Concatenation + { + get + { + return Keys.GetString(Keys.Concatenation); + } + } + + public static string ConcatenationDescription + { + get + { + return Keys.GetString(Keys.ConcatenationDescription); + } + } + + public static string ConstantScan + { + get + { + return Keys.GetString(Keys.ConstantScan); + } + } + + public static string ConstantScanDescription + { + get + { + return Keys.GetString(Keys.ConstantScanDescription); + } + } + + public static string Parallelism + { + get + { + return Keys.GetString(Keys.Parallelism); + } + } + + public static string ParallelismDescription + { + get + { + return Keys.GetString(Keys.ParallelismDescription); + } + } + + public static string Put + { + get + { + return Keys.GetString(Keys.Put); + } + } + + public static string PutDescription + { + get + { + return Keys.GetString(Keys.PutDescription); + } + } + + public static string DistributeStreams + { + get + { + return Keys.GetString(Keys.DistributeStreams); + } + } + + public static string DistributeStreamsDescription + { + get + { + return Keys.GetString(Keys.DistributeStreamsDescription); + } + } + + public static string GatherStreams + { + get + { + return Keys.GetString(Keys.GatherStreams); + } + } + + public static string GatherStreamsDescription + { + get + { + return Keys.GetString(Keys.GatherStreamsDescription); + } + } + + public static string RepartitionStreams + { + get + { + return Keys.GetString(Keys.RepartitionStreams); + } + } + + public static string RepartitionStreamsDescription + { + get + { + return Keys.GetString(Keys.RepartitionStreamsDescription); + } + } + + public static string EagerSpool + { + get + { + return Keys.GetString(Keys.EagerSpool); + } + } + + public static string EagerSpoolDescription + { + get + { + return Keys.GetString(Keys.EagerSpoolDescription); + } + } + + public static string LazySpool + { + get + { + return Keys.GetString(Keys.LazySpool); + } + } + + public static string LazySpoolDescription + { + get + { + return Keys.GetString(Keys.LazySpoolDescription); + } + } + + public static string Filter + { + get + { + return Keys.GetString(Keys.Filter); + } + } + + public static string FilterDescription + { + get + { + return Keys.GetString(Keys.FilterDescription); + } + } + + public static string Assert + { + get + { + return Keys.GetString(Keys.Assert); + } + } + + public static string AssertDescription + { + get + { + return Keys.GetString(Keys.AssertDescription); + } + } + + public static string HashMatch + { + get + { + return Keys.GetString(Keys.HashMatch); + } + } + + public static string HashMatchDescription + { + get + { + return Keys.GetString(Keys.HashMatchDescription); + } + } + + public static string HashMatchTeam + { + get + { + return Keys.GetString(Keys.HashMatchTeam); + } + } + + public static string HashMatchTeamDescription + { + get + { + return Keys.GetString(Keys.HashMatchTeamDescription); + } + } + + public static string HashMatchRoot + { + get + { + return Keys.GetString(Keys.HashMatchRoot); + } + } + + public static string HashMatchRootDescription + { + get + { + return Keys.GetString(Keys.HashMatchRootDescription); + } + } + + public static string BookmarkLookup + { + get + { + return Keys.GetString(Keys.BookmarkLookup); + } + } + + public static string BookmarkLookupDescription + { + get + { + return Keys.GetString(Keys.BookmarkLookupDescription); + } + } + + public static string LogRowScan + { + get + { + return Keys.GetString(Keys.LogRowScan); + } + } + + public static string LogRowScanDescription + { + get + { + return Keys.GetString(Keys.LogRowScanDescription); + } + } + + public static string MergeJoin + { + get + { + return Keys.GetString(Keys.MergeJoin); + } + } + + public static string MergeJoinDescription + { + get + { + return Keys.GetString(Keys.MergeJoinDescription); + } + } + + public static string NestedLoops + { + get + { + return Keys.GetString(Keys.NestedLoops); + } + } + + public static string NestedLoopsDescription + { + get + { + return Keys.GetString(Keys.NestedLoopsDescription); + } + } + + public static string Print + { + get + { + return Keys.GetString(Keys.Print); + } + } + + public static string PrintDescription + { + get + { + return Keys.GetString(Keys.PrintDescription); + } + } + + public static string ComputeScalar + { + get + { + return Keys.GetString(Keys.ComputeScalar); + } + } + + public static string ComputeScalarDescription + { + get + { + return Keys.GetString(Keys.ComputeScalarDescription); + } + } + + public static string MergeInterval + { + get + { + return Keys.GetString(Keys.MergeInterval); + } + } + + public static string MergeIntervalDescription + { + get + { + return Keys.GetString(Keys.MergeIntervalDescription); + } + } + + public static string Rank + { + get + { + return Keys.GetString(Keys.Rank); + } + } + + public static string RankDescription + { + get + { + return Keys.GetString(Keys.RankDescription); + } + } + + public static string RowCountSpool + { + get + { + return Keys.GetString(Keys.RowCountSpool); + } + } + + public static string RowCountSpoolDescription + { + get + { + return Keys.GetString(Keys.RowCountSpoolDescription); + } + } + + public static string Segment + { + get + { + return Keys.GetString(Keys.Segment); + } + } + + public static string SegmentDescription + { + get + { + return Keys.GetString(Keys.SegmentDescription); + } + } + + public static string Sequence + { + get + { + return Keys.GetString(Keys.Sequence); + } + } + + public static string SequenceDescription + { + get + { + return Keys.GetString(Keys.SequenceDescription); + } + } + + public static string SequenceProject + { + get + { + return Keys.GetString(Keys.SequenceProject); + } + } + + public static string SequenceProjectDescription + { + get + { + return Keys.GetString(Keys.SequenceProjectDescription); + } + } + + public static string Split + { + get + { + return Keys.GetString(Keys.Split); + } + } + + public static string SplitDescription + { + get + { + return Keys.GetString(Keys.SplitDescription); + } + } + + public static string StreamAggregate + { + get + { + return Keys.GetString(Keys.StreamAggregate); + } + } + + public static string StreamAggregateDescription + { + get + { + return Keys.GetString(Keys.StreamAggregateDescription); + } + } + + public static string TableScan + { + get + { + return Keys.GetString(Keys.TableScan); + } + } + + public static string TableScanDescription + { + get + { + return Keys.GetString(Keys.TableScanDescription); + } + } + + public static string ClusteredIndexScan + { + get + { + return Keys.GetString(Keys.ClusteredIndexScan); + } + } + + public static string ClusteredIndexScanDescription + { + get + { + return Keys.GetString(Keys.ClusteredIndexScanDescription); + } + } + + public static string ClusteredIndexSeek + { + get + { + return Keys.GetString(Keys.ClusteredIndexSeek); + } + } + + public static string ClusteredIndexSeekDescription + { + get + { + return Keys.GetString(Keys.ClusteredIndexSeekDescription); + } + } + + public static string DeletedScan + { + get + { + return Keys.GetString(Keys.DeletedScan); + } + } + + public static string DeletedScanDescription + { + get + { + return Keys.GetString(Keys.DeletedScanDescription); + } + } + + public static string InsertedScan + { + get + { + return Keys.GetString(Keys.InsertedScan); + } + } + + public static string InsertedScanDescription + { + get + { + return Keys.GetString(Keys.InsertedScanDescription); + } + } + + public static string ParameterTableScan + { + get + { + return Keys.GetString(Keys.ParameterTableScan); + } + } + + public static string ParameterTableScanDescription + { + get + { + return Keys.GetString(Keys.ParameterTableScanDescription); + } + } + + public static string IndexScan + { + get + { + return Keys.GetString(Keys.IndexScan); + } + } + + public static string IndexScanDescription + { + get + { + return Keys.GetString(Keys.IndexScanDescription); + } + } + + public static string IndexSeek + { + get + { + return Keys.GetString(Keys.IndexSeek); + } + } + + public static string IndexSeekDescription + { + get + { + return Keys.GetString(Keys.IndexSeekDescription); + } + } + + public static string ColumnstoreIndexScan + { + get + { + return Keys.GetString(Keys.ColumnstoreIndexScan); + } + } + + public static string ColumnstoreIndexScanDescription + { + get + { + return Keys.GetString(Keys.ColumnstoreIndexScanDescription); + } + } + + public static string ColumnstoreIndexUpdate + { + get + { + return Keys.GetString(Keys.ColumnstoreIndexUpdate); + } + } + + public static string ColumnstoreIndexUpdateDescription + { + get + { + return Keys.GetString(Keys.ColumnstoreIndexUpdateDescription); + } + } + + public static string ColumnstoreIndexInsert + { + get + { + return Keys.GetString(Keys.ColumnstoreIndexInsert); + } + } + + public static string ColumnstoreIndexInsertDescription + { + get + { + return Keys.GetString(Keys.ColumnstoreIndexInsertDescription); + } + } + + public static string ColumnstoreIndexMerge + { + get + { + return Keys.GetString(Keys.ColumnstoreIndexMerge); + } + } + + public static string ColumnstoreIndexMergeDescription + { + get + { + return Keys.GetString(Keys.ColumnstoreIndexMergeDescription); + } + } + + public static string ColumnstoreIndexDelete + { + get + { + return Keys.GetString(Keys.ColumnstoreIndexDelete); + } + } + + public static string ColumnstoreIndexDeleteDescription + { + get + { + return Keys.GetString(Keys.ColumnstoreIndexDeleteDescription); + } + } + + public static string RemoteScan + { + get + { + return Keys.GetString(Keys.RemoteScan); + } + } + + public static string RemoteScanDescription + { + get + { + return Keys.GetString(Keys.RemoteScanDescription); + } + } + + public static string RemoteIndexScan + { + get + { + return Keys.GetString(Keys.RemoteIndexScan); + } + } + + public static string RemoteIndexScanDescription + { + get + { + return Keys.GetString(Keys.RemoteIndexScanDescription); + } + } + + public static string RemoteIndexSeek + { + get + { + return Keys.GetString(Keys.RemoteIndexSeek); + } + } + + public static string RemoteIndexSeekDescription + { + get + { + return Keys.GetString(Keys.RemoteIndexSeekDescription); + } + } + + public static string RemoteQuery + { + get + { + return Keys.GetString(Keys.RemoteQuery); + } + } + + public static string RemoteQueryDescription + { + get + { + return Keys.GetString(Keys.RemoteQueryDescription); + } + } + + public static string RemoteInsert + { + get + { + return Keys.GetString(Keys.RemoteInsert); + } + } + + public static string RemoteInsertDescription + { + get + { + return Keys.GetString(Keys.RemoteInsertDescription); + } + } + + public static string RemoteUpdate + { + get + { + return Keys.GetString(Keys.RemoteUpdate); + } + } + + public static string RemoteUpdateDescription + { + get + { + return Keys.GetString(Keys.RemoteUpdateDescription); + } + } + + public static string RemoteDelete + { + get + { + return Keys.GetString(Keys.RemoteDelete); + } + } + + public static string RemoteDeleteDescription + { + get + { + return Keys.GetString(Keys.RemoteDeleteDescription); + } + } + + public static string ClusteredUpdate + { + get + { + return Keys.GetString(Keys.ClusteredUpdate); + } + } + + public static string ClusteredUpdateDescription + { + get + { + return Keys.GetString(Keys.ClusteredUpdateDescription); + } + } + + public static string Sort + { + get + { + return Keys.GetString(Keys.Sort); + } + } + + public static string SortDescription + { + get + { + return Keys.GetString(Keys.SortDescription); + } + } + + public static string TableSpool + { + get + { + return Keys.GetString(Keys.TableSpool); + } + } + + public static string TableSpoolDescription + { + get + { + return Keys.GetString(Keys.TableSpoolDescription); + } + } + + public static string IndexSpool + { + get + { + return Keys.GetString(Keys.IndexSpool); + } + } + + public static string IndexSpoolDescription + { + get + { + return Keys.GetString(Keys.IndexSpoolDescription); + } + } + + public static string TableUpdate + { + get + { + return Keys.GetString(Keys.TableUpdate); + } + } + + public static string TableUpdateDescription + { + get + { + return Keys.GetString(Keys.TableUpdateDescription); + } + } + + public static string TableInsert + { + get + { + return Keys.GetString(Keys.TableInsert); + } + } + + public static string TableInsertDescription + { + get + { + return Keys.GetString(Keys.TableInsertDescription); + } + } + + public static string TableDelete + { + get + { + return Keys.GetString(Keys.TableDelete); + } + } + + public static string TableDeleteDescription + { + get + { + return Keys.GetString(Keys.TableDeleteDescription); + } + } + + public static string TableMerge + { + get + { + return Keys.GetString(Keys.TableMerge); + } + } + + public static string TableMergeDescription + { + get + { + return Keys.GetString(Keys.TableMergeDescription); + } + } + + public static string IndexUpdate + { + get + { + return Keys.GetString(Keys.IndexUpdate); + } + } + + public static string IndexUpdateDescription + { + get + { + return Keys.GetString(Keys.IndexUpdateDescription); + } + } + + public static string IndexInsert + { + get + { + return Keys.GetString(Keys.IndexInsert); + } + } + + public static string IndexInsertDescription + { + get + { + return Keys.GetString(Keys.IndexInsertDescription); + } + } + + public static string IndexDelete + { + get + { + return Keys.GetString(Keys.IndexDelete); + } + } + + public static string IndexDeleteDescription + { + get + { + return Keys.GetString(Keys.IndexDeleteDescription); + } + } + + public static string ClusteredIndexUpdate + { + get + { + return Keys.GetString(Keys.ClusteredIndexUpdate); + } + } + + public static string ClusteredIndexUpdateDescription + { + get + { + return Keys.GetString(Keys.ClusteredIndexUpdateDescription); + } + } + + public static string ClusteredIndexInsert + { + get + { + return Keys.GetString(Keys.ClusteredIndexInsert); + } + } + + public static string ClusteredIndexInsertDescription + { + get + { + return Keys.GetString(Keys.ClusteredIndexInsertDescription); + } + } + + public static string ClusteredIndexMerge + { + get + { + return Keys.GetString(Keys.ClusteredIndexMerge); + } + } + + public static string ClusteredIndexMergeDescription + { + get + { + return Keys.GetString(Keys.ClusteredIndexMergeDescription); + } + } + + public static string ClusteredIndexDelete + { + get + { + return Keys.GetString(Keys.ClusteredIndexDelete); + } + } + + public static string ClusteredIndexDeleteDescription + { + get + { + return Keys.GetString(Keys.ClusteredIndexDeleteDescription); + } + } + + public static string Top + { + get + { + return Keys.GetString(Keys.Top); + } + } + + public static string TopDescription + { + get + { + return Keys.GetString(Keys.TopDescription); + } + } + + public static string Bitmap + { + get + { + return Keys.GetString(Keys.Bitmap); + } + } + + public static string BitmapDescription + { + get + { + return Keys.GetString(Keys.BitmapDescription); + } + } + + public static string UDX + { + get + { + return Keys.GetString(Keys.UDX); + } + } + + public static string UDXDescription + { + get + { + return Keys.GetString(Keys.UDXDescription); + } + } + + public static string Window + { + get + { + return Keys.GetString(Keys.Window); + } + } + + public static string WindowDescription + { + get + { + return Keys.GetString(Keys.WindowDescription); + } + } + + public static string WindowAggregate + { + get + { + return Keys.GetString(Keys.WindowAggregate); + } + } + + public static string WindowAggregateDescription + { + get + { + return Keys.GetString(Keys.WindowAggregateDescription); + } + } + + public static string BatchHashTableBuild + { + get + { + return Keys.GetString(Keys.BatchHashTableBuild); + } + } + + public static string BatchHashTableBuildDescription + { + get + { + return Keys.GetString(Keys.BatchHashTableBuildDescription); + } + } + + public static string Switch + { + get + { + return Keys.GetString(Keys.Switch); + } + } + + public static string SwitchDescription + { + get + { + return Keys.GetString(Keys.SwitchDescription); + } + } + + public static string TFP + { + get + { + return Keys.GetString(Keys.TFP); + } + } + + public static string TFPDescription + { + get + { + return Keys.GetString(Keys.TFPDescription); + } + } + + public static string TableValueFunction + { + get + { + return Keys.GetString(Keys.TableValueFunction); + } + } + + public static string TableValueFunctionDescription + { + get + { + return Keys.GetString(Keys.TableValueFunctionDescription); + } + } + + public static string Aggregate + { + get + { + return Keys.GetString(Keys.Aggregate); + } + } + + public static string AggregateDescription + { + get + { + return Keys.GetString(Keys.AggregateDescription); + } + } + + public static string ArithmeticExpression + { + get + { + return Keys.GetString(Keys.ArithmeticExpression); + } + } + + public static string ArithmeticExpressionDescription + { + get + { + return Keys.GetString(Keys.ArithmeticExpressionDescription); + } + } + + public static string Delete + { + get + { + return Keys.GetString(Keys.Delete); + } + } + + public static string DeleteDescription + { + get + { + return Keys.GetString(Keys.DeleteDescription); + } + } + + public static string Insert + { + get + { + return Keys.GetString(Keys.Insert); + } + } + + public static string InsertDescription + { + get + { + return Keys.GetString(Keys.InsertDescription); + } + } + + public static string Locate + { + get + { + return Keys.GetString(Keys.Locate); + } + } + + public static string LocateDescription + { + get + { + return Keys.GetString(Keys.LocateDescription); + } + } + + public static string Spool + { + get + { + return Keys.GetString(Keys.Spool); + } + } + + public static string SpoolDescription + { + get + { + return Keys.GetString(Keys.SpoolDescription); + } + } + + public static string SQL + { + get + { + return Keys.GetString(Keys.SQL); + } + } + + public static string SQLDescription + { + get + { + return Keys.GetString(Keys.SQLDescription); + } + } + + public static string Update + { + get + { + return Keys.GetString(Keys.Update); + } + } + + public static string UpdateDescription + { + get + { + return Keys.GetString(Keys.UpdateDescription); + } + } + + public static string Assign + { + get + { + return Keys.GetString(Keys.Assign); + } + } + + public static string AssignDescription + { + get + { + return Keys.GetString(Keys.AssignDescription); + } + } + + public static string Convert + { + get + { + return Keys.GetString(Keys.Convert); + } + } + + public static string ConvertDescription + { + get + { + return Keys.GetString(Keys.ConvertDescription); + } + } + + public static string Declare + { + get + { + return Keys.GetString(Keys.Declare); + } + } + + public static string DeclareDescription + { + get + { + return Keys.GetString(Keys.DeclareDescription); + } + } + + public static string If + { + get + { + return Keys.GetString(Keys.If); + } + } + + public static string IfDescription + { + get + { + return Keys.GetString(Keys.IfDescription); + } + } + + public static string Intrinsic + { + get + { + return Keys.GetString(Keys.Intrinsic); + } + } + + public static string IntrinsicDescription + { + get + { + return Keys.GetString(Keys.IntrinsicDescription); + } + } + + public static string SetFunction + { + get + { + return Keys.GetString(Keys.SetFunction); + } + } + + public static string SetFunctionDescription + { + get + { + return Keys.GetString(Keys.SetFunctionDescription); + } + } + + public static string Dynamic + { + get + { + return Keys.GetString(Keys.Dynamic); + } + } + + public static string DynamicDescription + { + get + { + return Keys.GetString(Keys.DynamicDescription); + } + } + + public static string FetchQuery + { + get + { + return Keys.GetString(Keys.FetchQuery); + } + } + + public static string FetchQueryDescription + { + get + { + return Keys.GetString(Keys.FetchQueryDescription); + } + } + + public static string FastForward + { + get + { + return Keys.GetString(Keys.FastForward); + } + } + + public static string FastForwardDescription + { + get + { + return Keys.GetString(Keys.FastForwardDescription); + } + } + + public static string Keyset + { + get + { + return Keys.GetString(Keys.Keyset); + } + } + + public static string KeysetDescription + { + get + { + return Keys.GetString(Keys.KeysetDescription); + } + } + + public static string PopulationQuery + { + get + { + return Keys.GetString(Keys.PopulationQuery); + } + } + + public static string PopulationQueryDescription + { + get + { + return Keys.GetString(Keys.PopulationQueryDescription); + } + } + + public static string RefreshQuery + { + get + { + return Keys.GetString(Keys.RefreshQuery); + } + } + + public static string RefreshQueryDescription + { + get + { + return Keys.GetString(Keys.RefreshQueryDescription); + } + } + + public static string Snapshot + { + get + { + return Keys.GetString(Keys.Snapshot); + } + } + + public static string SnapshotDescription + { + get + { + return Keys.GetString(Keys.SnapshotDescription); + } + } + + public static string RIDLookup + { + get + { + return Keys.GetString(Keys.RIDLookup); + } + } + + public static string RIDLookupDescription + { + get + { + return Keys.GetString(Keys.RIDLookupDescription); + } + } + + public static string KeyLookup + { + get + { + return Keys.GetString(Keys.KeyLookup); + } + } + + public static string KeyLookupDescription + { + get + { + return Keys.GetString(Keys.KeyLookupDescription); + } + } + + public static string LogicalKeyLookup + { + get + { + return Keys.GetString(Keys.LogicalKeyLookup); + } + } + + public static string AdaptiveJoin + { + get + { + return Keys.GetString(Keys.AdaptiveJoin); + } + } + + public static string AdaptiveJoinDescription + { + get + { + return Keys.GetString(Keys.AdaptiveJoinDescription); + } + } + + public static string ForeignKeyReferencesCheck + { + get + { + return Keys.GetString(Keys.ForeignKeyReferencesCheck); + } + } + + public static string ForeignKeyReferencesCheckDescription + { + get + { + return Keys.GetString(Keys.ForeignKeyReferencesCheckDescription); + } + } + + public static string Apply + { + get + { + return Keys.GetString(Keys.Apply); + } + } + + public static string ApplyDescription + { + get + { + return Keys.GetString(Keys.ApplyDescription); + } + } + + public static string Broadcast + { + get + { + return Keys.GetString(Keys.Broadcast); + } + } + + public static string BroadcastDescription + { + get + { + return Keys.GetString(Keys.BroadcastDescription); + } + } + + public static string ComputeToControlNode + { + get + { + return Keys.GetString(Keys.ComputeToControlNode); + } + } + + public static string ComputeToControlNodeDescription + { + get + { + return Keys.GetString(Keys.ComputeToControlNodeDescription); + } + } + + public static string ConstTableGet + { + get + { + return Keys.GetString(Keys.ConstTableGet); + } + } + + public static string ConstTableGetDescription + { + get + { + return Keys.GetString(Keys.ConstTableGetDescription); + } + } + + public static string ControlToComputeNodes + { + get + { + return Keys.GetString(Keys.ControlToComputeNodes); + } + } + + public static string ControlToComputeNodesDescription + { + get + { + return Keys.GetString(Keys.ControlToComputeNodesDescription); + } + } + + public static string ExternalBroadcast + { + get + { + return Keys.GetString(Keys.ExternalBroadcast); + } + } + + public static string ExternalBroadcastDescription + { + get + { + return Keys.GetString(Keys.ExternalBroadcastDescription); + } + } + + public static string ExternalExport + { + get + { + return Keys.GetString(Keys.ExternalExport); + } + } + + public static string ExternalExportDescription + { + get + { + return Keys.GetString(Keys.ExternalExportDescription); + } + } + + public static string ExternalLocalStreaming + { + get + { + return Keys.GetString(Keys.ExternalLocalStreaming); + } + } + + public static string ExternalLocalStreamingDescription + { + get + { + return Keys.GetString(Keys.ExternalLocalStreamingDescription); + } + } + + public static string ExternalRoundRobin + { + get + { + return Keys.GetString(Keys.ExternalRoundRobin); + } + } + + public static string ExternalRoundRobinDescription + { + get + { + return Keys.GetString(Keys.ExternalRoundRobinDescription); + } + } + + public static string ExternalShuffle + { + get + { + return Keys.GetString(Keys.ExternalShuffle); + } + } + + public static string ExternalShuffleDescription + { + get + { + return Keys.GetString(Keys.ExternalShuffleDescription); + } + } + + public static string Get + { + get + { + return Keys.GetString(Keys.Get); + } + } + + public static string GetDescription + { + get + { + return Keys.GetString(Keys.GetDescription); + } + } + + public static string GbApply + { + get + { + return Keys.GetString(Keys.GbApply); + } + } + + public static string GbApplyDescription + { + get + { + return Keys.GetString(Keys.GbApplyDescription); + } + } + + public static string GbAgg + { + get + { + return Keys.GetString(Keys.GbAgg); + } + } + + public static string GbAggDescription + { + get + { + return Keys.GetString(Keys.GbAggDescription); + } + } + + public static string Join + { + get + { + return Keys.GetString(Keys.Join); + } + } + + public static string JoinDescription + { + get + { + return Keys.GetString(Keys.JoinDescription); + } + } + + public static string LocalCube + { + get + { + return Keys.GetString(Keys.LocalCube); + } + } + + public static string LocalCubeDescription + { + get + { + return Keys.GetString(Keys.LocalCubeDescription); + } + } + + public static string Project + { + get + { + return Keys.GetString(Keys.Project); + } + } + + public static string ProjectDescription + { + get + { + return Keys.GetString(Keys.ProjectDescription); + } + } + + public static string Shuffle + { + get + { + return Keys.GetString(Keys.Shuffle); + } + } + + public static string ShuffleDescription + { + get + { + return Keys.GetString(Keys.ShuffleDescription); + } + } + + public static string SingleSourceRoundRobin + { + get + { + return Keys.GetString(Keys.SingleSourceRoundRobin); + } + } + + public static string SingleSourceRoundRobinDescription + { + get + { + return Keys.GetString(Keys.SingleSourceRoundRobinDescription); + } + } + + public static string SingleSourceShuffle + { + get + { + return Keys.GetString(Keys.SingleSourceShuffle); + } + } + + public static string SingleSourceShuffleDescription + { + get + { + return Keys.GetString(Keys.SingleSourceShuffleDescription); + } + } + + public static string Trim + { + get + { + return Keys.GetString(Keys.Trim); + } + } + + public static string TrimDescription + { + get + { + return Keys.GetString(Keys.TrimDescription); + } + } + + public static string Union + { + get + { + return Keys.GetString(Keys.Union); + } + } + + public static string UnionDescription + { + get + { + return Keys.GetString(Keys.UnionDescription); + } + } + + public static string UnionAll + { + get + { + return Keys.GetString(Keys.UnionAll); + } + } + + public static string UnionAllDescription + { + get + { + return Keys.GetString(Keys.UnionAllDescription); + } + } + + public static string SizeInBytesFormat + { + get + { + return Keys.GetString(Keys.SizeInBytesFormat); + } + } + + public static string SizeInKiloBytesFormat + { + get + { + return Keys.GetString(Keys.SizeInKiloBytesFormat); + } + } + + public static string SizeInMegaBytesFormat + { + get + { + return Keys.GetString(Keys.SizeInMegaBytesFormat); + } + } + + public static string SizeInGigaBytesFormat + { + get + { + return Keys.GetString(Keys.SizeInGigaBytesFormat); + } + } + + public static string SizeInTeraBytesFormat + { + get + { + return Keys.GetString(Keys.SizeInTeraBytesFormat); + } + } + public static string ConnectionServiceListDbErrorNotConnected(string uri) { return Keys.GetString(Keys.ConnectionServiceListDbErrorNotConnected, uri); @@ -3296,6 +8680,36 @@ namespace Microsoft.SqlTools.ServiceLayer return Keys.GetString(Keys.MoreThanOneAzureFunctionWithName, functionName, fileName); } + public static string CostFormat(int x) + { + return Keys.GetString(Keys.CostFormat, x); + } + + public static string RuntimeCounterThread(int index) + { + return Keys.GetString(Keys.RuntimeCounterThread, index); + } + + public static string RuntimeCounterThreadOnInstance(int thread, int instance) + { + return Keys.GetString(Keys.RuntimeCounterThreadOnInstance, thread, instance); + } + + public static string ZoomLevelShouldBeBetween(int minimum, int maximum) + { + return Keys.GetString(Keys.ZoomLevelShouldBeBetween, minimum, maximum); + } + + public static string UnknownCursorPlanOperation(string name) + { + return Keys.GetString(Keys.UnknownCursorPlanOperation, name); + } + + public static string NameValuePair(string name, string value) + { + return Keys.GetString(Keys.NameValuePair, name, value); + } + [System.Runtime.CompilerServices.CompilerGeneratedAttribute()] public class Keys { @@ -4582,6 +9996,2043 @@ namespace Microsoft.SqlTools.ServiceLayer public const string SqlBindingsNet5NotSupported = "SqlBindingsNet5NotSupported"; + public const string Statement = "Statement"; + + + public const string StatementDesc = "StatementDesc"; + + + public const string PhysicalOperation = "PhysicalOperation"; + + + public const string PhysicalOperationDesc = "PhysicalOperationDesc"; + + + public const string LogicalOperation = "LogicalOperation"; + + + public const string LogicalOperationDesc = "LogicalOperationDesc"; + + + public const string OperationDescriptionShort = "OperationDescriptionShort"; + + + public const string OperationDescription = "OperationDescription"; + + + public const string OperationArgumentShort = "OperationArgumentShort"; + + + public const string OperationArgumentDescription = "OperationArgumentDescription"; + + + public const string ObjectShort = "ObjectShort"; + + + public const string ObjectDescription = "ObjectDescription"; + + + public const string IndexKind = "IndexKind"; + + + public const string IndexKindDescription = "IndexKindDescription"; + + + public const string DefinedValues = "DefinedValues"; + + + public const string DefinedValuesDescription = "DefinedValuesDescription"; + + + public const string OutputList = "OutputList"; + + + public const string OutputListDescription = "OutputListDescription"; + + + public const string Warnings = "Warnings"; + + + public const string WarningsDescription = "WarningsDescription"; + + + public const string Parallel = "Parallel"; + + + public const string ParallelDescription = "ParallelDescription"; + + + public const string EstimatedNumberOfRowsPerExecution = "EstimatedNumberOfRowsPerExecution"; + + + public const string EstimatedNumberOfRowsPerExecutionDescription = "EstimatedNumberOfRowsPerExecutionDescription"; + + + public const string EstimatedNumberOfRowsForAllExecutions = "EstimatedNumberOfRowsForAllExecutions"; + + + public const string EstimatedNumberOfRowsForAllExecutionsDescription = "EstimatedNumberOfRowsForAllExecutionsDescription"; + + + public const string EstimatedRowsRead = "EstimatedRowsRead"; + + + public const string EstimatedRowsReadDescription = "EstimatedRowsReadDescription"; + + + public const string IsGraphDBTransitiveClosure = "IsGraphDBTransitiveClosure"; + + + public const string IsGraphDBTransitiveClosureDescription = "IsGraphDBTransitiveClosureDescription"; + + + public const string IsInterleavedExecuted = "IsInterleavedExecuted"; + + + public const string IsInterleavedExecutedDescription = "IsInterleavedExecutedDescription"; + + + public const string IsAdaptive = "IsAdaptive"; + + + public const string IsAdaptiveDescription = "IsAdaptiveDescription"; + + + public const string AdaptiveThresholdRows = "AdaptiveThresholdRows"; + + + public const string AdaptiveThresholdRowsDescription = "AdaptiveThresholdRowsDescription"; + + + public const string EstimatedJoinType = "EstimatedJoinType"; + + + public const string EstimatedJoinTypeDescription = "EstimatedJoinTypeDescription"; + + + public const string ActualJoinType = "ActualJoinType"; + + + public const string ActualJoinTypeDescription = "ActualJoinTypeDescription"; + + + public const string EstimatedRowSize = "EstimatedRowSize"; + + + public const string EstimatedRowSizeDescription = "EstimatedRowSizeDescription"; + + + public const string EstimatedIoCost = "EstimatedIoCost"; + + + public const string EstimatedIoCostDescription = "EstimatedIoCostDescription"; + + + public const string EstimatedCpuCost = "EstimatedCpuCost"; + + + public const string EstimatedCpuCostDescription = "EstimatedCpuCostDescription"; + + + public const string EstimatedNumberOfExecutions = "EstimatedNumberOfExecutions"; + + + public const string EstimatedNumberOfExecutionsDescription = "EstimatedNumberOfExecutionsDescription"; + + + public const string EstimatedOperatorCost = "EstimatedOperatorCost"; + + + public const string EstimatedOperatorCostDescription = "EstimatedOperatorCostDescription"; + + + public const string EstimatedSubtreeCost = "EstimatedSubtreeCost"; + + + public const string EstimatedSubtreeCostDescription = "EstimatedSubtreeCostDescription"; + + + public const string NumberOfRows = "NumberOfRows"; + + + public const string NumberOfRowsDescription = "NumberOfRowsDescription"; + + + public const string ActualRowsRead = "ActualRowsRead"; + + + public const string ActualRowsReadDescription = "ActualRowsReadDescription"; + + + public const string NumberOfBatches = "NumberOfBatches"; + + + public const string NumberOfBatchesDescription = "NumberOfBatchesDescription"; + + + public const string NumberOfExecutions = "NumberOfExecutions"; + + + public const string NumberOfExecutionsDescription = "NumberOfExecutionsDescription"; + + + public const string EstimatedDataSize = "EstimatedDataSize"; + + + public const string EstimatedDataSizeDescription = "EstimatedDataSizeDescription"; + + + public const string ParameterList = "ParameterList"; + + + public const string ParameterListDescription = "ParameterListDescription"; + + + public const string MemoryFractions = "MemoryFractions"; + + + public const string MemoryFractionsDescription = "MemoryFractionsDescription"; + + + public const string MemoryFractionsInput = "MemoryFractionsInput"; + + + public const string MemoryFractionsInputDescription = "MemoryFractionsInputDescription"; + + + public const string MemoryFractionsOutput = "MemoryFractionsOutput"; + + + public const string MemoryFractionsOutputDescription = "MemoryFractionsOutputDescription"; + + + public const string UdxName = "UdxName"; + + + public const string UdxNameDescription = "UdxNameDescription"; + + + public const string Values = "Values"; + + + public const string ValuesDescription = "ValuesDescription"; + + + public const string CachedPlanSize = "CachedPlanSize"; + + + public const string CachedPlanSizeDescription = "CachedPlanSizeDescription"; + + + public const string UsePlan = "UsePlan"; + + + public const string ContainsInlineScalarTsqlUdfs = "ContainsInlineScalarTsqlUdfs"; + + + public const string DegreeOfParallelism = "DegreeOfParallelism"; + + + public const string DegreeOfParallelismDescription = "DegreeOfParallelismDescription"; + + + public const string EffectiveDegreeOfParallelism = "EffectiveDegreeOfParallelism"; + + + public const string EffectiveDegreeOfParallelismDescription = "EffectiveDegreeOfParallelismDescription"; + + + public const string MemoryGrant = "MemoryGrant"; + + + public const string MemoryGrantDescription = "MemoryGrantDescription"; + + + public const string RemoteDestination = "RemoteDestination"; + + + public const string RemoteDestinationDescription = "RemoteDestinationDescription"; + + + public const string RemoteObject = "RemoteObject"; + + + public const string RemoteObjectDescription = "RemoteObjectDescription"; + + + public const string RemoteSource = "RemoteSource"; + + + public const string RemoteSourceDescription = "RemoteSourceDescription"; + + + public const string UsedUdxColumns = "UsedUdxColumns"; + + + public const string UsedUdxColumnsDescription = "UsedUdxColumnsDescription"; + + + public const string InnerSideJoinColumns = "InnerSideJoinColumns"; + + + public const string InnerSideJoinColumnsDescription = "InnerSideJoinColumnsDescription"; + + + public const string OuterSideJoinColumns = "OuterSideJoinColumns"; + + + public const string OuterSideJoinColumnsDescription = "OuterSideJoinColumnsDescription"; + + + public const string WhereJoinColumns = "WhereJoinColumns"; + + + public const string Residual = "Residual"; + + + public const string ResidualDescription = "ResidualDescription"; + + + public const string PassThru = "PassThru"; + + + public const string PassThruDescription = "PassThruDescription"; + + + public const string ManyToMany = "ManyToMany"; + + + public const string ManyToManyDescription = "ManyToManyDescription"; + + + public const string PartitionColumns = "PartitionColumns"; + + + public const string PartitionColumnsDescription = "PartitionColumnsDescription"; + + + public const string Ascending = "Ascending"; + + + public const string Descending = "Descending"; + + + public const string HashKeys = "HashKeys"; + + + public const string HashKeysDescription = "HashKeysDescription"; + + + public const string ProbeColumn = "ProbeColumn"; + + + public const string ProbeColumnDescription = "ProbeColumnDescription"; + + + public const string PartitioningType = "PartitioningType"; + + + public const string PartitioningTypeDescription = "PartitioningTypeDescription"; + + + public const string GroupBy = "GroupBy"; + + + public const string GroupByDescription = "GroupByDescription"; + + + public const string GroupingSets = "GroupingSets"; + + + public const string GroupingSetsDescription = "GroupingSetsDescription"; + + + public const string SegmentColumn = "SegmentColumn"; + + + public const string SegmentColumnDescription = "SegmentColumnDescription"; + + + public const string RankColumns = "RankColumns"; + + + public const string RankColumnsDescription = "RankColumnsDescription"; + + + public const string Predicate = "Predicate"; + + + public const string PredicateDescription = "PredicateDescription"; + + + public const string OuterReferences = "OuterReferences"; + + + public const string OuterReferencesDescription = "OuterReferencesDescription"; + + + public const string ScalarOperator = "ScalarOperator"; + + + public const string ActionColumn = "ActionColumn"; + + + public const string ActionColumnDescription = "ActionColumnDescription"; + + + public const string OriginalActionColumn = "OriginalActionColumn"; + + + public const string OriginalActionColumnDescription = "OriginalActionColumnDescription"; + + + public const string Rows = "Rows"; + + + public const string RowsDescription = "RowsDescription"; + + + public const string SeekPredicate = "SeekPredicate"; + + + public const string SeekPredicateDescription = "SeekPredicateDescription"; + + + public const string Partitioned = "Partitioned"; + + + public const string PartitionedDescription = "PartitionedDescription"; + + + public const string SeekKeys = "SeekKeys"; + + + public const string SeekKeysDescription = "SeekKeysDescription"; + + + public const string PartitionsAccessed = "PartitionsAccessed"; + + + public const string PartitionCount = "PartitionCount"; + + + public const string TieColumns = "TieColumns"; + + + public const string TieColumnsDescription = "TieColumnsDescription"; + + + public const string IsPercent = "IsPercent"; + + + public const string IsPercentDescription = "IsPercentDescription"; + + + public const string WithTies = "WithTies"; + + + public const string WithTiesDescription = "WithTiesDescription"; + + + public const string PartitionId = "PartitionId"; + + + public const string PartitionIdDescription = "PartitionIdDescription"; + + + public const string Ordered = "Ordered"; + + + public const string OrderedDescription = "OrderedDescription"; + + + public const string ScanDirection = "ScanDirection"; + + + public const string ScanDirectionDescription = "ScanDirectionDescription"; + + + public const string ForcedIndex = "ForcedIndex"; + + + public const string ForcedIndexDescription = "ForcedIndexDescription"; + + + public const string SetPredicate = "SetPredicate"; + + + public const string SetPredicateDescription = "SetPredicateDescription"; + + + public const string TopExpression = "TopExpression"; + + + public const string TopExpressionDescription = "TopExpressionDescription"; + + + public const string HashKeysBuild = "HashKeysBuild"; + + + public const string HashKeysBuildDescription = "HashKeysBuildDescription"; + + + public const string HashKeysProbe = "HashKeysProbe"; + + + public const string HashKeysProbeDescription = "HashKeysProbeDescription"; + + + public const string BuildResidual = "BuildResidual"; + + + public const string BuildResidualDescription = "BuildResidualDescription"; + + + public const string ProbeResidual = "ProbeResidual"; + + + public const string ProbeResidualDescription = "ProbeResidualDescription"; + + + public const string SeekPredicates = "SeekPredicates"; + + + public const string SeekPredicatesDescription = "SeekPredicatesDescription"; + + + public const string SetOptions = "SetOptions"; + + + public const string SetOptionsDescription = "SetOptionsDescription"; + + + public const string OptimizationLevel = "OptimizationLevel"; + + + public const string OptimizationLevelDescription = "OptimizationLevelDescription"; + + + public const string StatementOptmEarlyAbortReason = "StatementOptmEarlyAbortReason"; + + + public const string TimeOut = "TimeOut"; + + + public const string MemoryLimitExceeded = "MemoryLimitExceeded"; + + + public const string GoodEnoughPlanFound = "GoodEnoughPlanFound"; + + + public const string EstimatedRebinds = "EstimatedRebinds"; + + + public const string EstimatedRebindsDescription = "EstimatedRebindsDescription"; + + + public const string EstimatedRewinds = "EstimatedRewinds"; + + + public const string EstimatedRewindsDescription = "EstimatedRewindsDescription"; + + + public const string ActualLocallyAggregatedRows = "ActualLocallyAggregatedRows"; + + + public const string ActualLocallyAggregatedRowsDescription = "ActualLocallyAggregatedRowsDescription"; + + + public const string ActualRebinds = "ActualRebinds"; + + + public const string ActualRebindsDescription = "ActualRebindsDescription"; + + + public const string ActualRewinds = "ActualRewinds"; + + + public const string ActualRewindsDescription = "ActualRewindsDescription"; + + + public const string ActualIOStatistics = "ActualIOStatistics"; + + + public const string ActualIOStatisticsDescription = "ActualIOStatisticsDescription"; + + + public const string ActualTimeStatistics = "ActualTimeStatistics"; + + + public const string ActualTimeStatisticsDescription = "ActualTimeStatisticsDescription"; + + + public const string ActualElapsedms = "ActualElapsedms"; + + + public const string ActualElapsedmsDescription = "ActualElapsedmsDescription"; + + + public const string ActualCPUms = "ActualCPUms"; + + + public const string ActualCPUmsDescription = "ActualCPUmsDescription"; + + + public const string ActualScans = "ActualScans"; + + + public const string ActualScansDescription = "ActualScansDescription"; + + + public const string ActualLogicalReads = "ActualLogicalReads"; + + + public const string ActualLogicalReadsDescription = "ActualLogicalReadsDescription"; + + + public const string ActualPhysicalReads = "ActualPhysicalReads"; + + + public const string ActualPhysicalReadsDescription = "ActualPhysicalReadsDescription"; + + + public const string ActualPageServerReads = "ActualPageServerReads"; + + + public const string ActualPageServerReadsDescription = "ActualPageServerReadsDescription"; + + + public const string ActualReadAheads = "ActualReadAheads"; + + + public const string ActualReadAheadsDescription = "ActualReadAheadsDescription"; + + + public const string ActualPageServerReadAheads = "ActualPageServerReadAheads"; + + + public const string ActualPageServerReadAheadsDescription = "ActualPageServerReadAheadsDescription"; + + + public const string ActualLobLogicalReads = "ActualLobLogicalReads"; + + + public const string ActualLobLogicalReadsDescription = "ActualLobLogicalReadsDescription"; + + + public const string ActualLobPhysicalReads = "ActualLobPhysicalReads"; + + + public const string ActualLobPhysicalReadsDescription = "ActualLobPhysicalReadsDescription"; + + + public const string ActualLobPageServerReads = "ActualLobPageServerReads"; + + + public const string ActualLobPageServerReadsDescription = "ActualLobPageServerReadsDescription"; + + + public const string ActualLobReadAheads = "ActualLobReadAheads"; + + + public const string ActualLobReadAheadsDescription = "ActualLobReadAheadsDescription"; + + + public const string ActualLobPageServerReadAheads = "ActualLobPageServerReadAheads"; + + + public const string ActualLobPageServerReadAheadsDescription = "ActualLobPageServerReadAheadsDescription"; + + + public const string ActualMemoryGrantStats = "ActualMemoryGrantStats"; + + + public const string HpcRowCount = "HpcRowCount"; + + + public const string HpcRowCountDescription = "HpcRowCountDescription"; + + + public const string HpcKernelElapsedUs = "HpcKernelElapsedUs"; + + + public const string HpcKernelElapsedUsDescription = "HpcKernelElapsedUsDescription"; + + + public const string HpcHostToDeviceBytes = "HpcHostToDeviceBytes"; + + + public const string HpcHostToDeviceBytesDescription = "HpcHostToDeviceBytesDescription"; + + + public const string HpcDeviceToHostBytes = "HpcDeviceToHostBytes"; + + + public const string HpcDeviceToHostBytesDescription = "HpcDeviceToHostBytesDescription"; + + + public const string InputMemoryGrant = "InputMemoryGrant"; + + + public const string OutputMemoryGrant = "OutputMemoryGrant"; + + + public const string UsedMemoryGrant = "UsedMemoryGrant"; + + + public const string Distinct = "Distinct"; + + + public const string DistinctDescription = "DistinctDescription"; + + + public const string OrderBy = "OrderBy"; + + + public const string OrderByDescription = "OrderByDescription"; + + + public const string SpillOccurredDisplayString = "SpillOccurredDisplayString"; + + + public const string ColumnsWithNoStatistics = "ColumnsWithNoStatistics"; + + + public const string ColumnsWithNoStatisticsDescription = "ColumnsWithNoStatisticsDescription"; + + + public const string NoJoinPredicate = "NoJoinPredicate"; + + + public const string NoJoinPredicateDescription = "NoJoinPredicateDescription"; + + + public const string SpillToTempDbOld = "SpillToTempDbOld"; + + + public const string SpillToTempDb = "SpillToTempDb"; + + + public const string SpillToTempDbDescription = "SpillToTempDbDescription"; + + + public const string SortSpillDetails = "SortSpillDetails"; + + + public const string SortSpillDetailsDescription = "SortSpillDetailsDescription"; + + + public const string HashSpillDetails = "HashSpillDetails"; + + + public const string HashSpillDetailsDescription = "HashSpillDetailsDescription"; + + + public const string FullUpdateForOnlineIndexBuild = "FullUpdateForOnlineIndexBuild"; + + + public const string FullUpdateForOnlineIndexBuildDescription = "FullUpdateForOnlineIndexBuildDescription"; + + + public const string Wait = "Wait"; + + + public const string WaitDescription = "WaitDescription"; + + + public const string PlanAffectingConvert = "PlanAffectingConvert"; + + + public const string PlanAffectingConvertDescription = "PlanAffectingConvertDescription"; + + + public const string MemoryGrantWarning = "MemoryGrantWarning"; + + + public const string MemoryGrantWarningDescription = "MemoryGrantWarningDescription"; + + + public const string StartupExpression = "StartupExpression"; + + + public const string StartupExpressionDescription = "StartupExpressionDescription"; + + + public const string StartupExpressionPredicate = "StartupExpressionPredicate"; + + + public const string Query = "Query"; + + + public const string Stack = "Stack"; + + + public const string RowCount = "RowCount"; + + + public const string Optimized = "Optimized"; + + + public const string WithPrefetch = "WithPrefetch"; + + + public const string Prefix = "Prefix"; + + + public const string StartRange = "StartRange"; + + + public const string StartRangeDescription = "StartRangeDescription"; + + + public const string EndRange = "EndRange"; + + + public const string EndRangeDescription = "EndRangeDescription"; + + + public const string RangeColumns = "RangeColumns"; + + + public const string RangeExpressions = "RangeExpressions"; + + + public const string ScanType = "ScanType"; + + + public const string ColumnReference = "ColumnReference"; + + + public const string ObjectServer = "ObjectServer"; + + + public const string ObjectServerDescription = "ObjectServerDescription"; + + + public const string ObjectDatabase = "ObjectDatabase"; + + + public const string ObjectDatabaseDescription = "ObjectDatabaseDescription"; + + + public const string ObjectIndex = "ObjectIndex"; + + + public const string ObjectIndexDescription = "ObjectIndexDescription"; + + + public const string ObjectSchema = "ObjectSchema"; + + + public const string ObjectSchemaDescription = "ObjectSchemaDescription"; + + + public const string ObjectTable = "ObjectTable"; + + + public const string ObjectTableDescription = "ObjectTableDescription"; + + + public const string ObjectAlias = "ObjectAlias"; + + + public const string ObjectAliasDescription = "ObjectAliasDescription"; + + + public const string ObjectColumn = "ObjectColumn"; + + + public const string ObjectColumnDescription = "ObjectColumnDescription"; + + + public const string ObjectComputedColumn = "ObjectComputedColumn"; + + + public const string ObjectComputedColumnDescription = "ObjectComputedColumnDescription"; + + + public const string ParameterDataType = "ParameterDataType"; + + + public const string ParameterCompiledValue = "ParameterCompiledValue"; + + + public const string ParameterRuntimeValue = "ParameterRuntimeValue"; + + + public const string CursorPlan = "CursorPlan"; + + + public const string CursorOperation = "CursorOperation"; + + + public const string CursorName = "CursorName"; + + + public const string CursorActualType = "CursorActualType"; + + + public const string CursorRequestedType = "CursorRequestedType"; + + + public const string CursorConcurrency = "CursorConcurrency"; + + + public const string ForwardOnly = "ForwardOnly"; + + + public const string QueryPlan = "QueryPlan"; + + + public const string OperationType = "OperationType"; + + + public const string NodeId = "NodeId"; + + + public const string PrimaryNodeId = "PrimaryNodeId"; + + + public const string InternalInfo = "InternalInfo"; + + + public const string ForeignKeyReferencesCount = "ForeignKeyReferencesCount"; + + + public const string NoMatchingIndexCount = "NoMatchingIndexCount"; + + + public const string PartialMatchingIndexCount = "PartialMatchingIndexCount"; + + + public const string LogicalOpCollapse = "LogicalOpCollapse"; + + + public const string LogicalOpConcatenation = "LogicalOpConcatenation"; + + + public const string LogicalOpConstantScan = "LogicalOpConstantScan"; + + + public const string LogicalOpGatherStreams = "LogicalOpGatherStreams"; + + + public const string LogicalOpRepartitionStreams = "LogicalOpRepartitionStreams"; + + + public const string LogicalOpDistributeStreams = "LogicalOpDistributeStreams"; + + + public const string LogicalOpFilter = "LogicalOpFilter"; + + + public const string LogicalOpAssert = "LogicalOpAssert"; + + + public const string LogicalOpLogRowScan = "LogicalOpLogRowScan"; + + + public const string LogicalOpPrint = "LogicalOpPrint"; + + + public const string LogicalOpComputeScalar = "LogicalOpComputeScalar"; + + + public const string LogicalOpMergeInterval = "LogicalOpMergeInterval"; + + + public const string LogicalOpRank = "LogicalOpRank"; + + + public const string LogicalOpSegment = "LogicalOpSegment"; + + + public const string LogicalOpSequence = "LogicalOpSequence"; + + + public const string LogicalOpSplit = "LogicalOpSplit"; + + + public const string LogicalOpAggregate = "LogicalOpAggregate"; + + + public const string LogicalOpTableScan = "LogicalOpTableScan"; + + + public const string LogicalOpClusteredIndexScan = "LogicalOpClusteredIndexScan"; + + + public const string LogicalOpClusteredIndexSeek = "LogicalOpClusteredIndexSeek"; + + + public const string LogicalOpDeletedScan = "LogicalOpDeletedScan"; + + + public const string LogicalOpInsertedScan = "LogicalOpInsertedScan"; + + + public const string LogicalOpParameterTableScan = "LogicalOpParameterTableScan"; + + + public const string LogicalOpPut = "LogicalOpPut"; + + + public const string LogicalOpIndexScan = "LogicalOpIndexScan"; + + + public const string LogicalOpIndexSeek = "LogicalOpIndexSeek"; + + + public const string LogicalOpRemoteScan = "LogicalOpRemoteScan"; + + + public const string LogicalOpRemoteIndexScan = "LogicalOpRemoteIndexScan"; + + + public const string LogicalOpRemoteIndexSeek = "LogicalOpRemoteIndexSeek"; + + + public const string LogicalOpRemoteQuery = "LogicalOpRemoteQuery"; + + + public const string LogicalOpRemoteInsert = "LogicalOpRemoteInsert"; + + + public const string LogicalOpRemoteUpdate = "LogicalOpRemoteUpdate"; + + + public const string LogicalOpRemoteDelete = "LogicalOpRemoteDelete"; + + + public const string LogicalOpClusteredUpdate = "LogicalOpClusteredUpdate"; + + + public const string LogicalOpDistinctSort = "LogicalOpDistinctSort"; + + + public const string LogicalOpSort = "LogicalOpSort"; + + + public const string LogicalOpTopNSort = "LogicalOpTopNSort"; + + + public const string LogicalOpEagerSpool = "LogicalOpEagerSpool"; + + + public const string LogicalOpLazySpool = "LogicalOpLazySpool"; + + + public const string LogicalOpUpdate = "LogicalOpUpdate"; + + + public const string LogicalOpInsert = "LogicalOpInsert"; + + + public const string LogicalOpDelete = "LogicalOpDelete"; + + + public const string LogicalOpMerge = "LogicalOpMerge"; + + + public const string LogicalOpTop = "LogicalOpTop"; + + + public const string LogicalOpDistinct = "LogicalOpDistinct"; + + + public const string LogicalOpFlowDistinct = "LogicalOpFlowDistinct"; + + + public const string LogicalOpPartialAggregate = "LogicalOpPartialAggregate"; + + + public const string LogicalOpInnerApply = "LogicalOpInnerApply"; + + + public const string LogicalOpInnerJoin = "LogicalOpInnerJoin"; + + + public const string LogicalOpLeftAntiSemiApply = "LogicalOpLeftAntiSemiApply"; + + + public const string LogicalOpLeftSemiApply = "LogicalOpLeftSemiApply"; + + + public const string LogicalOpLeftOuterApply = "LogicalOpLeftOuterApply"; + + + public const string LogicalOpLeftOuterJoin = "LogicalOpLeftOuterJoin"; + + + public const string LogicalOpRightOuterJoin = "LogicalOpRightOuterJoin"; + + + public const string LogicalOpFullOuterJoin = "LogicalOpFullOuterJoin"; + + + public const string LogicalOpLeftSemiJoin = "LogicalOpLeftSemiJoin"; + + + public const string LogicalOpLeftAntiSemiJoin = "LogicalOpLeftAntiSemiJoin"; + + + public const string LogicalOpRightSemiJoin = "LogicalOpRightSemiJoin"; + + + public const string LogicalOpRightAntiSemiJoin = "LogicalOpRightAntiSemiJoin"; + + + public const string LogicalOpIntersect = "LogicalOpIntersect"; + + + public const string LogicalOpIntersectAll = "LogicalOpIntersectAll"; + + + public const string LogicalOpUnion = "LogicalOpUnion"; + + + public const string LogicalOpLeftDiff = "LogicalOpLeftDiff"; + + + public const string LogicalOpLeftDiffAll = "LogicalOpLeftDiffAll"; + + + public const string LogicalOpRightDiff = "LogicalOpRightDiff"; + + + public const string LogicalOpRightDiffAll = "LogicalOpRightDiffAll"; + + + public const string LogicalOpAntiDiff = "LogicalOpAntiDiff"; + + + public const string LogicalOpCrossJoin = "LogicalOpCrossJoin"; + + + public const string LogicalOpBitmapCreate = "LogicalOpBitmapCreate"; + + + public const string LogicalOpUDX = "LogicalOpUDX"; + + + public const string LogicalOpWindow = "LogicalOpWindow"; + + + public const string LogicalOpSwitch = "LogicalOpSwitch"; + + + public const string LogicalOpMergeStats = "LogicalOpMergeStats"; + + + public const string LogicalOpLocalStats = "LogicalOpLocalStats"; + + + public const string LogicalOpTableValuedFunction = "LogicalOpTableValuedFunction"; + + + public const string LogicalOpBatchHashTableBuild = "LogicalOpBatchHashTableBuild"; + + + public const string LogicalOpForeignKeyReferencesCheck = "LogicalOpForeignKeyReferencesCheck"; + + + public const string LogicalOpRIDLookup = "LogicalOpRIDLookup"; + + + public const string StoredProc = "StoredProc"; + + + public const string Udf = "Udf"; + + + public const string ProcName = "ProcName"; + + + public const string Storage = "Storage"; + + + public const string StorageDesc = "StorageDesc"; + + + public const string ActualExecMode = "ActualExecMode"; + + + public const string ActualExecModeDesc = "ActualExecModeDesc"; + + + public const string EstimatedExecMode = "EstimatedExecMode"; + + + public const string EstimatedExecModeDesc = "EstimatedExecModeDesc"; + + + public const string CostFormat = "CostFormat"; + + + public const string RemoteDataAccess = "RemoteDataAccess"; + + + public const string RemoteDataAccessDescription = "RemoteDataAccessDescription"; + + + public const string CloneAccessScope = "CloneAccessScope"; + + + public const string CloneAccessScopeDescription = "CloneAccessScopeDescription"; + + + public const string PrimaryClones = "PrimaryClones"; + + + public const string SecondaryClones = "SecondaryClones"; + + + public const string BothClones = "BothClones"; + + + public const string EitherClones = "EitherClones"; + + + public const string ExactMatchClones = "ExactMatchClones"; + + + public const string Remoting = "Remoting"; + + + public const string RemotingDescription = "RemotingDescription"; + + + public const string Activation = "Activation"; + + + public const string BrickRouting = "BrickRouting"; + + + public const string FragmentIdColumn = "FragmentIdColumn"; + + + public const string EditQueryText = "EditQueryText"; + + + public const string UnknownShowPlanSource = "UnknownShowPlanSource"; + + + public const string SavePlanFilter = "SavePlanFilter"; + + + public const string NoXmlPlanData = "NoXmlPlanData"; + + + public const string PerThreadCounterDescription = "PerThreadCounterDescription"; + + + public const string RuntimeCounterThread = "RuntimeCounterThread"; + + + public const string RuntimeCounterThreadOnInstance = "RuntimeCounterThreadOnInstance"; + + + public const string RuntimeCounterThreadAll = "RuntimeCounterThreadAll"; + + + public const string ConnectionPropertiesLabel = "ConnectionPropertiesLabel"; + + + public const string UnknownAssignType = "UnknownAssignType"; + + + public const string MessageBoxCaption = "MessageBoxCaption"; + + + public const string ZoomLevelShouldBeBetween = "ZoomLevelShouldBeBetween"; + + + public const string UnknownNodeType = "UnknownNodeType"; + + + public const string UnknownCursorPlanOperation = "UnknownCursorPlanOperation"; + + + public const string UnknownStatementType = "UnknownStatementType"; + + + public const string RollupInfo = "RollupInfo"; + + + public const string RollupInfoDescription = "RollupInfoDescription"; + + + public const string HighestLevel = "HighestLevel"; + + + public const string HighestLevelDescription = "HighestLevelDescription"; + + + public const string RollupLevel = "RollupLevel"; + + + public const string RollupLevelDescription = "RollupLevelDescription"; + + + public const string Level = "Level"; + + + public const string LevelDescription = "LevelDescription"; + + + public const string Unknown = "Unknown"; + + + public const string UnknownDescription = "UnknownDescription"; + + + public const string Result = "Result"; + + + public const string ResultDescription = "ResultDescription"; + + + public const string Collapse = "Collapse"; + + + public const string CollapseDescription = "CollapseDescription"; + + + public const string Concatenation = "Concatenation"; + + + public const string ConcatenationDescription = "ConcatenationDescription"; + + + public const string ConstantScan = "ConstantScan"; + + + public const string ConstantScanDescription = "ConstantScanDescription"; + + + public const string Parallelism = "Parallelism"; + + + public const string ParallelismDescription = "ParallelismDescription"; + + + public const string Put = "Put"; + + + public const string PutDescription = "PutDescription"; + + + public const string DistributeStreams = "DistributeStreams"; + + + public const string DistributeStreamsDescription = "DistributeStreamsDescription"; + + + public const string GatherStreams = "GatherStreams"; + + + public const string GatherStreamsDescription = "GatherStreamsDescription"; + + + public const string RepartitionStreams = "RepartitionStreams"; + + + public const string RepartitionStreamsDescription = "RepartitionStreamsDescription"; + + + public const string EagerSpool = "EagerSpool"; + + + public const string EagerSpoolDescription = "EagerSpoolDescription"; + + + public const string LazySpool = "LazySpool"; + + + public const string LazySpoolDescription = "LazySpoolDescription"; + + + public const string Filter = "Filter"; + + + public const string FilterDescription = "FilterDescription"; + + + public const string Assert = "Assert"; + + + public const string AssertDescription = "AssertDescription"; + + + public const string HashMatch = "HashMatch"; + + + public const string HashMatchDescription = "HashMatchDescription"; + + + public const string HashMatchTeam = "HashMatchTeam"; + + + public const string HashMatchTeamDescription = "HashMatchTeamDescription"; + + + public const string HashMatchRoot = "HashMatchRoot"; + + + public const string HashMatchRootDescription = "HashMatchRootDescription"; + + + public const string BookmarkLookup = "BookmarkLookup"; + + + public const string BookmarkLookupDescription = "BookmarkLookupDescription"; + + + public const string LogRowScan = "LogRowScan"; + + + public const string LogRowScanDescription = "LogRowScanDescription"; + + + public const string MergeJoin = "MergeJoin"; + + + public const string MergeJoinDescription = "MergeJoinDescription"; + + + public const string NestedLoops = "NestedLoops"; + + + public const string NestedLoopsDescription = "NestedLoopsDescription"; + + + public const string Print = "Print"; + + + public const string PrintDescription = "PrintDescription"; + + + public const string ComputeScalar = "ComputeScalar"; + + + public const string ComputeScalarDescription = "ComputeScalarDescription"; + + + public const string MergeInterval = "MergeInterval"; + + + public const string MergeIntervalDescription = "MergeIntervalDescription"; + + + public const string Rank = "Rank"; + + + public const string RankDescription = "RankDescription"; + + + public const string RowCountSpool = "RowCountSpool"; + + + public const string RowCountSpoolDescription = "RowCountSpoolDescription"; + + + public const string Segment = "Segment"; + + + public const string SegmentDescription = "SegmentDescription"; + + + public const string Sequence = "Sequence"; + + + public const string SequenceDescription = "SequenceDescription"; + + + public const string SequenceProject = "SequenceProject"; + + + public const string SequenceProjectDescription = "SequenceProjectDescription"; + + + public const string Split = "Split"; + + + public const string SplitDescription = "SplitDescription"; + + + public const string StreamAggregate = "StreamAggregate"; + + + public const string StreamAggregateDescription = "StreamAggregateDescription"; + + + public const string TableScan = "TableScan"; + + + public const string TableScanDescription = "TableScanDescription"; + + + public const string ClusteredIndexScan = "ClusteredIndexScan"; + + + public const string ClusteredIndexScanDescription = "ClusteredIndexScanDescription"; + + + public const string ClusteredIndexSeek = "ClusteredIndexSeek"; + + + public const string ClusteredIndexSeekDescription = "ClusteredIndexSeekDescription"; + + + public const string DeletedScan = "DeletedScan"; + + + public const string DeletedScanDescription = "DeletedScanDescription"; + + + public const string InsertedScan = "InsertedScan"; + + + public const string InsertedScanDescription = "InsertedScanDescription"; + + + public const string ParameterTableScan = "ParameterTableScan"; + + + public const string ParameterTableScanDescription = "ParameterTableScanDescription"; + + + public const string IndexScan = "IndexScan"; + + + public const string IndexScanDescription = "IndexScanDescription"; + + + public const string IndexSeek = "IndexSeek"; + + + public const string IndexSeekDescription = "IndexSeekDescription"; + + + public const string ColumnstoreIndexScan = "ColumnstoreIndexScan"; + + + public const string ColumnstoreIndexScanDescription = "ColumnstoreIndexScanDescription"; + + + public const string ColumnstoreIndexUpdate = "ColumnstoreIndexUpdate"; + + + public const string ColumnstoreIndexUpdateDescription = "ColumnstoreIndexUpdateDescription"; + + + public const string ColumnstoreIndexInsert = "ColumnstoreIndexInsert"; + + + public const string ColumnstoreIndexInsertDescription = "ColumnstoreIndexInsertDescription"; + + + public const string ColumnstoreIndexMerge = "ColumnstoreIndexMerge"; + + + public const string ColumnstoreIndexMergeDescription = "ColumnstoreIndexMergeDescription"; + + + public const string ColumnstoreIndexDelete = "ColumnstoreIndexDelete"; + + + public const string ColumnstoreIndexDeleteDescription = "ColumnstoreIndexDeleteDescription"; + + + public const string RemoteScan = "RemoteScan"; + + + public const string RemoteScanDescription = "RemoteScanDescription"; + + + public const string RemoteIndexScan = "RemoteIndexScan"; + + + public const string RemoteIndexScanDescription = "RemoteIndexScanDescription"; + + + public const string RemoteIndexSeek = "RemoteIndexSeek"; + + + public const string RemoteIndexSeekDescription = "RemoteIndexSeekDescription"; + + + public const string RemoteQuery = "RemoteQuery"; + + + public const string RemoteQueryDescription = "RemoteQueryDescription"; + + + public const string RemoteInsert = "RemoteInsert"; + + + public const string RemoteInsertDescription = "RemoteInsertDescription"; + + + public const string RemoteUpdate = "RemoteUpdate"; + + + public const string RemoteUpdateDescription = "RemoteUpdateDescription"; + + + public const string RemoteDelete = "RemoteDelete"; + + + public const string RemoteDeleteDescription = "RemoteDeleteDescription"; + + + public const string ClusteredUpdate = "ClusteredUpdate"; + + + public const string ClusteredUpdateDescription = "ClusteredUpdateDescription"; + + + public const string Sort = "Sort"; + + + public const string SortDescription = "SortDescription"; + + + public const string TableSpool = "TableSpool"; + + + public const string TableSpoolDescription = "TableSpoolDescription"; + + + public const string IndexSpool = "IndexSpool"; + + + public const string IndexSpoolDescription = "IndexSpoolDescription"; + + + public const string TableUpdate = "TableUpdate"; + + + public const string TableUpdateDescription = "TableUpdateDescription"; + + + public const string TableInsert = "TableInsert"; + + + public const string TableInsertDescription = "TableInsertDescription"; + + + public const string TableDelete = "TableDelete"; + + + public const string TableDeleteDescription = "TableDeleteDescription"; + + + public const string TableMerge = "TableMerge"; + + + public const string TableMergeDescription = "TableMergeDescription"; + + + public const string IndexUpdate = "IndexUpdate"; + + + public const string IndexUpdateDescription = "IndexUpdateDescription"; + + + public const string IndexInsert = "IndexInsert"; + + + public const string IndexInsertDescription = "IndexInsertDescription"; + + + public const string IndexDelete = "IndexDelete"; + + + public const string IndexDeleteDescription = "IndexDeleteDescription"; + + + public const string ClusteredIndexUpdate = "ClusteredIndexUpdate"; + + + public const string ClusteredIndexUpdateDescription = "ClusteredIndexUpdateDescription"; + + + public const string ClusteredIndexInsert = "ClusteredIndexInsert"; + + + public const string ClusteredIndexInsertDescription = "ClusteredIndexInsertDescription"; + + + public const string ClusteredIndexMerge = "ClusteredIndexMerge"; + + + public const string ClusteredIndexMergeDescription = "ClusteredIndexMergeDescription"; + + + public const string ClusteredIndexDelete = "ClusteredIndexDelete"; + + + public const string ClusteredIndexDeleteDescription = "ClusteredIndexDeleteDescription"; + + + public const string Top = "Top"; + + + public const string TopDescription = "TopDescription"; + + + public const string Bitmap = "Bitmap"; + + + public const string BitmapDescription = "BitmapDescription"; + + + public const string UDX = "UDX"; + + + public const string UDXDescription = "UDXDescription"; + + + public const string Window = "Window"; + + + public const string WindowDescription = "WindowDescription"; + + + public const string WindowAggregate = "WindowAggregate"; + + + public const string WindowAggregateDescription = "WindowAggregateDescription"; + + + public const string BatchHashTableBuild = "BatchHashTableBuild"; + + + public const string BatchHashTableBuildDescription = "BatchHashTableBuildDescription"; + + + public const string Switch = "Switch"; + + + public const string SwitchDescription = "SwitchDescription"; + + + public const string TFP = "TFP"; + + + public const string TFPDescription = "TFPDescription"; + + + public const string TableValueFunction = "TableValueFunction"; + + + public const string TableValueFunctionDescription = "TableValueFunctionDescription"; + + + public const string Aggregate = "Aggregate"; + + + public const string AggregateDescription = "AggregateDescription"; + + + public const string ArithmeticExpression = "ArithmeticExpression"; + + + public const string ArithmeticExpressionDescription = "ArithmeticExpressionDescription"; + + + public const string Delete = "Delete"; + + + public const string DeleteDescription = "DeleteDescription"; + + + public const string Insert = "Insert"; + + + public const string InsertDescription = "InsertDescription"; + + + public const string Locate = "Locate"; + + + public const string LocateDescription = "LocateDescription"; + + + public const string Spool = "Spool"; + + + public const string SpoolDescription = "SpoolDescription"; + + + public const string SQL = "SQL"; + + + public const string SQLDescription = "SQLDescription"; + + + public const string Update = "Update"; + + + public const string UpdateDescription = "UpdateDescription"; + + + public const string Assign = "Assign"; + + + public const string AssignDescription = "AssignDescription"; + + + public const string Convert = "Convert"; + + + public const string ConvertDescription = "ConvertDescription"; + + + public const string Declare = "Declare"; + + + public const string DeclareDescription = "DeclareDescription"; + + + public const string If = "If"; + + + public const string IfDescription = "IfDescription"; + + + public const string Intrinsic = "Intrinsic"; + + + public const string IntrinsicDescription = "IntrinsicDescription"; + + + public const string SetFunction = "SetFunction"; + + + public const string SetFunctionDescription = "SetFunctionDescription"; + + + public const string Dynamic = "Dynamic"; + + + public const string DynamicDescription = "DynamicDescription"; + + + public const string FetchQuery = "FetchQuery"; + + + public const string FetchQueryDescription = "FetchQueryDescription"; + + + public const string FastForward = "FastForward"; + + + public const string FastForwardDescription = "FastForwardDescription"; + + + public const string Keyset = "Keyset"; + + + public const string KeysetDescription = "KeysetDescription"; + + + public const string PopulationQuery = "PopulationQuery"; + + + public const string PopulationQueryDescription = "PopulationQueryDescription"; + + + public const string RefreshQuery = "RefreshQuery"; + + + public const string RefreshQueryDescription = "RefreshQueryDescription"; + + + public const string Snapshot = "Snapshot"; + + + public const string SnapshotDescription = "SnapshotDescription"; + + + public const string RIDLookup = "RIDLookup"; + + + public const string RIDLookupDescription = "RIDLookupDescription"; + + + public const string KeyLookup = "KeyLookup"; + + + public const string KeyLookupDescription = "KeyLookupDescription"; + + + public const string LogicalKeyLookup = "LogicalKeyLookup"; + + + public const string AdaptiveJoin = "AdaptiveJoin"; + + + public const string AdaptiveJoinDescription = "AdaptiveJoinDescription"; + + + public const string ForeignKeyReferencesCheck = "ForeignKeyReferencesCheck"; + + + public const string ForeignKeyReferencesCheckDescription = "ForeignKeyReferencesCheckDescription"; + + + public const string Apply = "Apply"; + + + public const string ApplyDescription = "ApplyDescription"; + + + public const string Broadcast = "Broadcast"; + + + public const string BroadcastDescription = "BroadcastDescription"; + + + public const string ComputeToControlNode = "ComputeToControlNode"; + + + public const string ComputeToControlNodeDescription = "ComputeToControlNodeDescription"; + + + public const string ConstTableGet = "ConstTableGet"; + + + public const string ConstTableGetDescription = "ConstTableGetDescription"; + + + public const string ControlToComputeNodes = "ControlToComputeNodes"; + + + public const string ControlToComputeNodesDescription = "ControlToComputeNodesDescription"; + + + public const string ExternalBroadcast = "ExternalBroadcast"; + + + public const string ExternalBroadcastDescription = "ExternalBroadcastDescription"; + + + public const string ExternalExport = "ExternalExport"; + + + public const string ExternalExportDescription = "ExternalExportDescription"; + + + public const string ExternalLocalStreaming = "ExternalLocalStreaming"; + + + public const string ExternalLocalStreamingDescription = "ExternalLocalStreamingDescription"; + + + public const string ExternalRoundRobin = "ExternalRoundRobin"; + + + public const string ExternalRoundRobinDescription = "ExternalRoundRobinDescription"; + + + public const string ExternalShuffle = "ExternalShuffle"; + + + public const string ExternalShuffleDescription = "ExternalShuffleDescription"; + + + public const string Get = "Get"; + + + public const string GetDescription = "GetDescription"; + + + public const string GbApply = "GbApply"; + + + public const string GbApplyDescription = "GbApplyDescription"; + + + public const string GbAgg = "GbAgg"; + + + public const string GbAggDescription = "GbAggDescription"; + + + public const string Join = "Join"; + + + public const string JoinDescription = "JoinDescription"; + + + public const string LocalCube = "LocalCube"; + + + public const string LocalCubeDescription = "LocalCubeDescription"; + + + public const string Project = "Project"; + + + public const string ProjectDescription = "ProjectDescription"; + + + public const string Shuffle = "Shuffle"; + + + public const string ShuffleDescription = "ShuffleDescription"; + + + public const string SingleSourceRoundRobin = "SingleSourceRoundRobin"; + + + public const string SingleSourceRoundRobinDescription = "SingleSourceRoundRobinDescription"; + + + public const string SingleSourceShuffle = "SingleSourceShuffle"; + + + public const string SingleSourceShuffleDescription = "SingleSourceShuffleDescription"; + + + public const string Trim = "Trim"; + + + public const string TrimDescription = "TrimDescription"; + + + public const string Union = "Union"; + + + public const string UnionDescription = "UnionDescription"; + + + public const string UnionAll = "UnionAll"; + + + public const string UnionAllDescription = "UnionAllDescription"; + + + public const string NameValuePair = "NameValuePair"; + + + public const string SizeInBytesFormat = "SizeInBytesFormat"; + + + public const string SizeInKiloBytesFormat = "SizeInKiloBytesFormat"; + + + public const string SizeInMegaBytesFormat = "SizeInMegaBytesFormat"; + + + public const string SizeInGigaBytesFormat = "SizeInGigaBytesFormat"; + + + public const string SizeInTeraBytesFormat = "SizeInTeraBytesFormat"; + + private Keys() { } diff --git a/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.resx b/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.resx index c71cb5ea..42f4edbf 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.resx +++ b/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.resx @@ -1868,4 +1868,2726 @@ Adding SQL bindings is not supported for .NET 5 + + Statement + Statement + + + In most cases, contains the text of the Transact-SQL statement. For rows of type PLAN_ROW, contains a description of the operation. + Statement description + + + Physical Operation + Physical Operation + + + Physical implementation algorithm for the node. For rows of type PLAN_ROWS only. + Physical Operation description + + + Logical Operation + Logical Operation + + + Relational algebraic operator this node represents. For rows of type PLAN_ROWS only. + Logical Operation description + + + Description + Operation description. Short + + + Operation description. + Operation description + + + Argument + Operation Argument. Short + + + Provides supplemental information about the operation being performed. The contents of this column depend on the physical operator. + Operation Argument description + + + Object + Object field + + + Object. + Object field description + + + Index Kind + IndexKind field + + + Type of index for the referenced object. + IndexKind field description + + + Defined Values + Defined Values + + + Contains a comma-separated list of values introduced by this operator, which may be computed expressions present in the current query, or internal values introduced by the query processor in order to process this query. For rows of type PLAN_ROWS only. + Defined Values description + + + Output List + Output List + + + Contains a comma-separated list of columns being projected by the current operation. + Output List + + + Warnings + Warnings + + + Contains a comma-separated list of warning messages relating to the current operation. Warning messages may include the string 'NO STATS:()' with a list of columns. + Warnings description + + + Parallel + Parallel + + + Whether the operator is running in parallel. + Parallel description + + + Estimated Number of Rows Per Execution + Estimated Number of Rows Per Execution + + + Estimated number of rows per execution output by this operator. This is for PLAN_ROWS only. + Estimated Number of Rows Per Execution description + + + Estimated Number of Rows for All Executions + Estimated Number of Rows for All Executions + + + Estimated number of rows for all executions output by this operator. This is for PLAN_ROWS only. + Estimated Number of Rows for All Executions description + + + Estimated Number of Rows to be Read + Estimated Rows Read + + + Number of rows estimated to be read by this operator. This value may differ from "Estimated Number of Rows for All Executions" if the operator has a predicate. + Estimated Rows Read description + + + Is GraphDB Transitive Closure + GraphDB Transitive Closure + + + Whether the sequence represents a GraphDB transitive closure. + GraphDB Transitive Closure Description + + + IsInterleavedExecuted + Interleaved Executed + + + Whether the operator is interleaved executed. + Interleaved Executed Description + + + Is Adaptive + Is Adaptive + + + Whether the operator is adaptive. + Is Adaptive description + + + Adaptive Threshold Rows + Adaptive Threshold Rows + + + If this is an adaptive operator, the cardinality at which it adapts. + Adaptive Threshold Rows description + + + Estimated Join Type + Estimated Join Type + + + The join type (nested loops or hash join) estimated by the query optimizer before adapting. + Estimated Join Type description + + + Actual Join Type + Actual Join Type + + + The actual join picked (nested loops or hash join) as part of adaptive join execution. + Actual Join Type Description + + + Estimated Row Size + Estimated Row Size + + + Estimated average row size of the row being passed through this operator. + Estimated Row Size description + + + Estimated I/O Cost + Estimated IO Cost + + + Estimated I/O cost for this operator. For rows of type PLAN_ROWS only. + Estimated IO Cost description + + + Estimated CPU Cost + Estimated CPU Cost + + + Estimated CPU cost for this operator. For rows of type PLAN_ROWS only. + Estimated CPU Cost description + + + Estimated Number of Executions + Estimated Number of Executions + + + Estimated number of times this operator will be executed while running the current query. + Estimated Number of Executions description + + + Estimated Operator Cost + Show plan node property name + + + Estimated cost of this operator. + Estimated Costs description + + + Estimated Subtree Cost + Estimated Subtree Cost + + + Estimated cumulative cost of this operation and all child operations. + Estimated Subtree Cost description + + + Actual Number of Rows for All Executions + Number of Rows + + + Actual number of rows for All Executions output by this operator. For rows of type PLAN_ROWS only. + Number of Rows description + + + Number of Rows Read + Number of Rows Read by a Rowset (Table or Index) + + + Number of rows read from a table or an index prior to applying a predicate filter. For rows of type PLAN_ROWS only. + Number of Rows Read by a Rowset (Table or Index) Description + + + Actual Number of Batches + Number of Batches + + + Actual number of Batches output by this operator. + Number of Batches description + + + Number of Executions + Number of Executions + + + Number of times this operator will be executed while running the current query. + Number of Executions description + + + Estimated Data Size + Estimated Data Size + + + Estimated data size of the data being passed through this operator. + Estimated Data Size description + + + Parameter List + Show plan's simple root node property + + + Parameter list. + Show plan's simple root node property description + + + Memory Fractions + Show plan's simple root node property + + + Memory fractions. + Show plan's simple root node property description + + + Memory Fractions Input + Show plan's simple root node property + + + Memory fractions input. + Show plan's simple root node property description + + + Memory Fractions Output + Show plan's simple root node property + + + Memory fractions output. + Show plan's simple root node property description + + + Name + Show plan's UDX node property + + + Name. + Show plan's UDX node property description + + + Values + Show plan's ConstantScan node property + + + Values. + Show plan's ConstantScan node property description + + + Cached plan size + CachedPlanSize property + + + Cached plan size. + Description for CachedPlanSize property + + + Use plan + UsePlan property + + + Contains Inline Scalar Tsql Udfs + InlineScalarTsqlUdf property + + + Degree of Parallelism + DegreeOfParallelism property + + + Degree of parallelism. + Description for DegreeOfParallelism property + + + Effective Degree of Parallelism + EffectiveDegreeOfParallelism property + + + Max degree of parallelism during columnstore index build. + Description for EffectiveDegreeOfParallelism property + + + Memory Grant + Root node for show plan property + + + Memory grant. + Description for MemoryGrant property + + + Remote Destination + Show plan node property + + + Remote object. + Show plan node property description + + + Remote Object + Show plan node property + + + Remote object. + Show plan node property description + + + Remote Source + Show plan node property + + + Remote source. + Show plan node property description + + + Used UDX Columns + Show plan node property + + + Used UDX columns. + Show plan node property description + + + Inner Side Join columns + Show plan node property + + + Inner side join columns. + Show plan node property description + + + Outer Side Join columns + Show plan node property + + + Outer side join columns. + Show plan node property description + + + Where (join columns) + Show plan node property + + + Residual + Show plan node property + + + Residual. + Show plan node property description + + + Pass Through + Show plan node property + + + Pass throuh. + Show plan node property description + + + Many to Many + Show plan node property + + + Many to many. + Show plan node property description + + + Partition Columns + Show plan node property + + + Partition columns. + Show plan node property description + + + Ascending + Column sort type + + + Descending + Column sort type + + + Hash Keys + Show plan node property + + + Hash keys. + Show plan node property description + + + Probe Column + Show plan node property + + + Probe column. + Show plan node property description + + + Partitioning Type + Show plan node property + + + Partitioning type. + Show plan node property description + + + Group By + Show plan node property + + + Group by. + Show plan node property description + + + Grouping Sets + Show plan node property + + + The group sets list. Each Value is a reverse bit map for the grouping columns in Group By property. + Show plan node property description + + + Segment Column + Show plan node property + + + Segment column. + Show plan node property description + + + Rank Columns + Show plan node property + + + Rank columns. + Show plan node property description + + + Predicate + Show plan node property + + + Predicate. + Show plan node property description + + + Outer References + Show plan node property + + + Outer references. + Show plan node property description + + + Scalar Operator + Show plan node property + + + Action Column + Show plan node property + + + Action column. + Show plan node property description + + + Original Action Column + Show plan node property + + + Original Action column. + Show plan node property description + + + Top Rows + Show plan node property + + + Top Rows. + Show plan node property description + + + Seek Predicate + Show plan node property + + + Seek predicate. + Show plan node property description + + + Partitioned + Show plan node property + + + Whether the operation is on a partitioned table or index. + Show plan node property description + + + Seek Keys + Show plan node property + + + Keys used by a seek operation. + Show plan node property description + + + Actual Partitions Accessed + Show plan node property + + + Actual Partition Count + Show plan node property + + + Tie Columns + Show plan node property + + + Tie columns. + Show plan node property description + + + Is Percent + Show plan node property + + + Is percent. + Show plan node property description + + + With Ties + Show plan node property + + + With ties. + Show plan node property description + + + Partition ID + Show plan node property + + + Partition ID. + Show plan node property description + + + Ordered + Show plan node property + + + Ordered. + Show plan node property description + + + Scan Direction + ScanDirection property + + + Direction of the scan operation as either forward or backward. + ScanDirection property description + + + Forced Index + Show plan node property + + + Forced index. + Show plan node property description + + + Predicate + Show plan node property + + + Predicate + Show plan node property description + + + Top Expression + Show plan node property + + + Top expression. + Show plan node property description + + + Hash Keys Build + Show plan node property + + + Hash keys build. + Show plan node property description + + + Hash Keys Probe + Show plan node property + + + Hash keys probe. + Show plan node property description + + + Build Residual + Show plan node property + + + Build residual. + Show plan node property description + + + Probe Residual + Show plan node property + + + Probe residual. + Show plan node property description + + + Seek Predicates + Show plan node property + + + Seek predicates. + Show plan node property description + + + Set Options + Set options property in show plan + + + Set options. + Set options property in show plan description + + + Optimization Level + Optimization Level property in show plan + + + Optimization level. + Optimization Level property in show plan description + + + Reason For Early Termination Of Statement Optimization + StatementOptmEarlyAbortReason property + + + Time Out + StatementOptmEarlyAbortReason property value + + + Memory Limit Exceeded + StatementOptmEarlyAbortReason property value + + + Good Enough Plan Found + StatementOptmEarlyAbortReason property value + + + Estimated Rebinds + Estimated Rebinds + + + Estimated rebinds. + Estimated Rebinds Description + + + Estimated Rewinds + Estimated Rewinds + + + Estimated rewinds. + Estimated Rewinds Description + + + Actual Number of Locally Aggregated Rows + Actual Locally Aggregated Rows + + + Actual number of locally aggregated rows + Actual Locally Aggregated Rows Description + + + Actual Rebinds + Actual Rebinds + + + Actual Rebinds. + Actual Rebinds Description + + + Actual Rewinds + Actual Rewinds + + + Actual Rewinds. + Actual Rewinds Description + + + Actual I/O Statistics + Actual I/O Statistics + + + Actual I/O Statistics + Actual I/O Statistics Description + + + Actual Time Statistics + Actual Time Statistics + + + Actual Time Statistics + Actual Time Statistics Description + + + Actual Elapsed Time (ms) + Actual Elapsed Milliseconds + + + Actual elapsed time in milliseconds + Actual Elapsed Milliseconds Description + + + Actual Elapsed CPU Time (ms) + Actual CPU Time Milliseconds + + + Actual elapsed CPU time in milliseconds + Actual CPU Time Milliseconds Description + + + Actual Scans + Actual Scans + + + Actual Scans + Actual Scans Description + + + Actual Logical Reads + Actual Logical Reads + + + Actual Logical Reads + Actual Logical Reads Description + + + Actual Physical Reads + Actual Physical Reads + + + Actual Physical Reads + Actual Physical Reads Description + + + Actual Page Server Reads + Actual Page Server Reads + + + Actual Page Server Reads + Actual Page Server Reads Description + + + Actual Read Aheads + Actual Read Aheads + + + Actual Read Aheads + Actual Read Aheads Description + + + Actual Page Server Read Aheads + Actual Page Server Read Aheads + + + Actual Page Server Read Aheads + Actual Page Server Read Aheads Description + + + Actual Lob Logical Reads + Actual Lob Logical Reads + + + Actual Lob Logical Reads + Actual Lob Logical Reads Description + + + Actual Lob Physical Reads + Actual Lob Physical Reads + + + Actual Lob Physical Reads + Actual Lob Physical Reads Description + + + Actual Lob Page Server Reads + Actual Lob Page Server Reads + + + Actual Lob Page Server Reads + Actual Lob Page Server Reads Description + + + Actual Lob Read Aheads + Actual Lob Read Aheads + + + Actual Lob Read Aheads + Actual Lob Read Aheads Description + + + Actual Lob Page Server Read Aheads + Actual Lob Page Server Read Aheads + + + Actual Lob Page Server Read Aheads + Actual Lob Page Server Read Aheads Description + + + Memory Usage + ActualMemoryGrantStats + + + Hpc Row Count + Hpc Row Count + + + Number of rows processed by Hpc devices. + Hpc Row Count Description + + + Hpc Kernel Elapsed Time in Us + Hpc Kernel Elapsed Us + + + Elapsed time (in micro seconds) of Hpc device kernel execution. + Hpc Kernel Elapsed Us Description + + + Hpc Host To Device Bytes + Hpc Host To Device Bytes + + + Data transferred from host to Hpc device in bytes. + Hpc Host To Device Bytes Description + + + Hpc Device To Host Bytes + Hpc Device To Host Bytes + + + Data transferred from Hpc device to host in bytes. + Hpc Device To Host Bytes Description + + + Input Memory + InputMemoryGrant + + + Output Memory + OutputMemoryGrant + + + Used Memory + UsedMemoryGrant + + + Distinct + Distinct + + + Distinct. + Distinct description + + + Order By + OrderBy + + + Order by. + OrderBy description + + + Operator used tempdb to spill data during execution + + + + Columns With No Statistics + ColumnsWithNoStatistics property + + + Columns with no statistics warning. + ColumnsWithNoStatistics property description + + + No Join Predicate + NoJoinPredicate property + + + No Join predicate warning. + NoJoinPredicate property description + + + Operator used tempdb to spill data during execution with spill level {0} + SpillToTempDbOld property + + + Operator used tempdb to spill data during execution with spill level {0} and {1} spilled thread(s) + SpillToTempDb property + + + Spill to tempdb warning. + SpillToTempDb property description + + + Sort wrote {0} pages to and read {1} pages from tempdb with granted memory {2}KB and used memory {3}KB + SortSpillDetails property + + + Details of sort spill + SortSpillDetails property description + + + Hash wrote {0} pages to and read {1} pages from tempdb with granted memory {2}KB and used memory {3}KB + HashSpillDetails property + + + Details of hash spill + HahSpillDetails property description + + + A partial update was converted to a full update because of an online index build + FullUpdateForOnlineIndexBuild property + + + Full update for online index build warning + FullUpdateForOnlineIndexBuild property description + + + The query had to wait {0} seconds for {1} during execution + Wait property + + + Query wait warning. + Wait property description + + + Type conversion in expression ({0}) may affect "{1}" in query plan choice + PlanAffectingConvert property + + + Plan-affecting type conversion warning. + PlanAffectingConvert property description + + + The query memory grant detected "{0}", which may impact the reliability. Grant size: Initial {1} KB, Final {2} KB, Used {3} KB. + MemoryGrantWarning property + + + Details on memory grant warning + MemoryGrantWarning property description + + + Startup Expression + StartupExpression property + + + Whether a filter startup expression is used. + StartupExpression property description + + + Startup Expression Predicate + StartupExpressionPredicate property + + + Query + Query property + + + With Stack + Stack property + + + Is Row Count + RowCount property + + + Optimized + Optimized property + + + With Prefetch + WithPrefetch property + + + Prefix + Prefix property + + + Start + StartRange property + + + Start of the range. + StartRange property description + + + End + EndRange property + + + End of the range. + EndRange property description + + + Range Columns + RangeColumns property + + + Range Expressions + RangeExpressions property + + + Scan Type + ScanType property + + + Column Reference + ColumnReference property + + + Server + Server property + + + Server name for the referenced object. + Server property description + + + Database + Database property + + + Database name for the referenced object. + Database property description + + + Index + Index property + + + Index name for the referenced object. + Index property description + + + Schema + Schema property + + + Schema name for the referenced object. + Schema property description + + + Table + Table property + + + Table name for the referenced object. + Table property description + + + Alias + Alias property + + + Alias used for the referenced object. + Alias property description + + + Column + Column property + + + Column name for the referenced object. + Column property description + + + Computed Column + ComputedColumn property + + + Whether this is a computed column. + ComputedColumn property description + + + Parameter Data Type + ParameterDataType property + + + Parameter Compiled Value + ParameterCompiledValue property + + + Parameter Runtime Value + ParameterRuntimeValue property + + + Cursor Plan + CursorPlan property + + + Cursor Operation + CursorOperation property + + + Cursor Name + CursorName property + + + Cursor Actual Type + CursorActualType property + + + Cursor Requested Type + CursorRequestedType property + + + Cursor Concurrency + CursorConcurrency property + + + Forward Only + ForwardOnly property + + + Query Plan + QueryPlan property + + + Operation Type + OperationType property + + + Node ID + Node ID property + + + Primary Node ID + Primary Node ID property + + + Internal Debugging Information + Internal Info property + + + Foreign Key References Count + Foreign Key References Count property + + + No Matching Indexes Count + No Matching Index Count property + + + Partial Matching Indexes Count + Partial Matching Index Count property + + + Collapse + Logical operator + + + Concatenation + Logical operator + + + Constant Scan + Logical operator + + + Gather Streams + Logical operator + + + Repartition Streams + Logical operator + + + Distribute Streams + Logical operator + + + Filter + Logical operator + + + Assert + Logical operator + + + Log Row Scan + Logical operator + + + Print + Logical operator + + + Compute Scalar + Logical operator + + + Merge Interval + Logical operator + + + Rank + Logical operator + + + Segment + Logical operator + + + Sequence + Logical operator + + + Split + Logical operator + + + Aggregate + Logical operator + + + Table Scan + Logical operator + + + Clustered Index Scan + Logical operator + + + Clustered Index Seek + Logical operator + + + Deleted Scan + Logical operator + + + Inserted Scan + Logical operator + + + Parameter Table Scan + Logical operator + + + Put + Logical operator + + + Index Scan + Logical operator + + + Index Seek + Logical operator + + + Remote Scan + Logical operator + + + Remote Index Scan + Logical operator + + + Remote Index Seek + Logical operator + + + Remote Query + Logical operator + + + Remote Insert + Logical operator + + + Remote Update + Logical operator + + + Remote Delete + Logical operator + + + Clustered Update + Logical operator + + + Distinct Sort + Logical operator + + + Sort + Logical operator + + + Top N Sort + Logical operator + + + Eager Spool + Logical operator + + + Lazy Spool + Logical operator + + + Update + Logical operator + + + Insert + Logical operator + + + Delete + Logical operator + + + Merge + Logical operator + + + Top + Logical operator + + + Distinct + Logical operator + + + Flow Distinct + Logical operator + + + Partial Aggregate + Logical operator + + + Inner Apply + Logical operator + + + Inner Join + Logical operator + + + Left Anti Semi Apply + Logical operator + + + Left Semi Apply + Logical operator + + + Left Outer Apply + Logical operator + + + Left Outer Join + Logical operator + + + Right Outer Join + Logical operator + + + Full Outer Join + Logical operator + + + Left Semi Join + Logical operator + + + Left Anti Semi Join + Logical operator + + + Right Semi Join + Logical operator + + + Right Anti Semi Join + Logical operator + + + Intersect + Logical operator + + + Intersect All + Logical operator + + + Union + Logical operator + + + Left Diff + Logical operator + + + Left Diff All + Logical operator + + + Right Diff + Logical operator + + + Right Diff All + Logical operator + + + Anti Diff + Logical operator + + + Cross Join + Logical operator + + + Bitmap Create + Logical operator + + + UDX + Logical operator + + + Window Spool + Logical operator + + + Switch + Logical operator + + + Merge Stats + Logical operator + + + Local Stats + Logical operator + + + Table Valued Function + Logical operator + + + Batch Hash Table Build + Logical operator + + + Foreign Key References Check + Logical operator + + + RID Lookup + RIDLookup operator + + + Stored Procedure + StoredProc node + + + UDF + UDF node + + + Procedure Name + ProcName property + + + Storage + Storage property + + + Storage + Storage property + + + Actual Execution Mode + ActualExectionMode property + + + Actual Execution Mode + + + + Estimated Execution Mode + EstimatedExecutionMode property + + + Estimated Execution Mode + + + + Cost: {0} % + "Cost: {0} percent" String to format. + Parameters: 0 - x (int) + + + Remote Data Access + Remote Data Access + + + Whether the operator uses remote procedure call (RPC) to access remote data. + + + + Clone Access Scope + Clone Access Scope + + + Clones that the operator may access. + + + + Primary Clones + + + + Secondary Clones + + + + All Clones + + + + Primary Or Secondary Clones + + + + Single Clone Match + + + + Remoting + Remoting for remote exchange operator + + + Whether the operator can run remotely. + + + + Activation + Activation + + + Brick Routing + Brick Routing + + + Fragment Id Column + + + + Edit Query Text from Showplan XML (possibly truncated) + Showplan edit query text button + + + Execution plan source type can not be recognized. + error message when the ShowPlan source cannot be recognized + + + Sql Plan files (*.SqlPlan)|*.SqlPlan|All files (*.*)|*.* + Save plan dialog filter string + + + Plan data is not available in XML format. Only plans from SQL Server Yukon can be saved. + Message box if user tries to save in XML show plan from Shiloh or Sphinx + + + Per-thread counter information. + Description of a per thread counter + + + Thread {0} + Runtime counter property name. + Parameters: 0 - index (int) + + + Thread {0} on Instance {1} + Runtime counter property name. Thread on Instance.. + Parameters: 0 - thread (int), 1 - instance (int) + + + All threads + Runtime counter property name + + + View connection properties + label for Connection Properties hyperlink + + + Unknown assign type. + Error when displaying show plan properties + + + SQL Server + exception message box caption + + + Zoom level must be an integer value between {0} and {1}. + Message shown when user enters wrong zoom level. + Parameters: 0 - minimum (int), 1 - maximum (int) + + + Unknown node type. + Exception thrown when node type is unknown + + + Unknown cursor plan operation '{0}'. + Exception thrown by show plan when it gets unknown type of cursor plan operation. + Parameters: 0 - name (string) + + + Statement type is not recognized. + Exception thrown by show plan when it gets unknown statement type + + + Rollup Information + Show plan node property + + + Rollup information. + Show plan node property description + + + Highest Level + Show plan node property + + + The highest level of grouping attributes computed in this rollup. + Show plan node property description + + + Rollup Levels + Show plan node property + + + All levels of grouping attributes computed in this rollup. + Show plan node property description + + + Level + Show plan node property + + + A level of grouping attributes computed in this rollup. + Show plan node property description + + + Unknown + Unkown (reused string, unkown operator, or unkown reason, or unknown ...) + + + Unknown operator. + Operator description + + + Result + Operator name + + + Result. + Operator description + + + Collapse + Operator name + + + Groups an insert and delete on the same value into an update within wide update plans. + Operator description + + + Concatenation + Operator name + + + Append multiple input tables to form the output table. + Operator description + + + Constant Scan + Operator name + + + Scan an internal table of constants. + Operator description + + + Parallelism + Operator name + + + An operation involving parallelism. + Operator description + + + Put + Operator name + + + Export the rows from a local or external table to an external table. + Operator description + + + Distribute Streams + Operator name + + + Distribute streams. + Operator description + + + Gather Streams + Operator name + + + Gather streams. + Operator description + + + Repartition Streams + Operator name + + + Repartition streams. + Operator description + + + Eager Spool + Operator name + + + Eager Spool. + Operator description + + + Lazy Spool + Operator name + + + Lazy Spool. + Operator description + + + Filter + Operator name + + + Restricting the set of rows based on a predicate. + Operator description + + + Assert + Operator name + + + Used to verify that a specified condition exists. + Operator description + + + Hash Match + Operator name + + + Use each row from the top input to build a hash table, and each row from the bottom input to probe into the hash table, outputting all matching rows. + Operator description + + + Hash Match Team + Operator name + + + A contributor among multiple cooperating hashing operations. + Operator description + + + Hash Match Root + Operator name + + + The root member of a team of connected hash operators sharing a common hash function and partitioning strategy. + Operator description + + + Bookmark Lookup + Operator name + + + Use a Bookmark (RID or clustering key) to look up the corresponding row in the table or clustered index. + Operator description + + + Log Row Scan + Operator name + + + Scan the rows in the log. + Operator description + + + Merge Join + Operator name + + + Match rows from two suitably sorted input tables exploiting their sort order. + Operator description + + + Nested Loops + Operator name + + + For each row in the top (outer) input, scan the bottom (inner) input, and output matching rows. + Operator description + + + Print + Operator name + + + Print. + Operator description + + + Compute Scalar + Operator name + + + Compute new values from existing values in a row. + Operator description + + + Merge Interval + Operator name + + + Merge interval. + Operator description + + + Rank + Operator name + + + Creates a computed column with the rank of the values in an existing column in the table. + Operator description + + + Row Count Spool + Operator name + + + Stores the data from the input into a temporary table in order to optimize rewinds. + Operator description + + + Segment + Operator name + + + Segment. + Operator description + + + Sequence + Operator name + + + Process each input, in sequence from top to bottom. + Operator description + + + Sequence Project + Operator name + + + Adds columns to perform computations over an ordered set. + Operator description + + + Split + Operator name + + + Split. + Operator description + + + Stream Aggregate + Operator name + + + Compute summary values for groups of rows in a suitably sorted stream. + Operator description + + + Table Scan + Operator name + + + Scan rows from a table. + Operator description + + + Clustered Index Scan + Operator name + + + Scanning a clustered index, entirely or only a range. + Operator description + + + Clustered Index Seek + Operator name + + + Scanning a particular range of rows from a clustered index. + Operator description + + + Deleted Scan + Operator name + + + Scanning the pseudo-table 'deleted' within a trigger. + Operator description + + + Inserted Scan + Operator name + + + Scan the pseudo-table 'inserted' within a trigger. + Operator description + + + Parameter Table Scan + Operator name + + + Scan an internal table of parameter values. + Operator description + + + Index Scan + Operator name + + + Scan a nonclustered index, entirely or only a range. + Operator description + + + Index Seek + Operator name + + + Scan a particular range of rows from a nonclustered index. + Operator description + + + Columnstore Index Scan + Operator name + + + Scan a columnstore index, entirely or only a range. + Operator description + + + Columnstore Index Update + Operator name + + + Update rows in a columnstore index. + Operator description + + + Columnstore Index Insert + Operator name + + + Insert rows in a columnstore index. + Operator description + + + Columnstore Index Merge + Operator name + + + Merge rows in a columnstore index. + Operator description + + + Columnstore Index Delete + Operator name + + + Delete rows from a columnstore index. + Operator description + + + Remote Scan + Operator name + + + Scan rows in a table stored in a database or file other than the current database server. + Operator description + + + Remote Index Scan + Operator name + + + Scan an index stored in a database or file other than the current database server. + Operator description + + + Remote Index Seek + Operator name + + + Scan a particular range of rows from a clustered index that is stored in a database or file other than the current database server. + Operator description + + + Remote Query + Operator name + + + Send a SQL query to another than the current SQL Server. + Operator description + + + Remote Insert + Operator name + + + Insert rows into a table stored in a database or file other than the current database server. + Operator description + + + Remote Update + Operator name + + + Update rows in a table stored in a database or file other than the current database server. + Operator description + + + Remote Delete + Operator name + + + Delete rows in a table stored in a database or file other than the current database server. + Operator description + + + Clustered Update + Operator name + + + Clustered Update. + Operator description + + + Sort + Operator name + + + Sort the input. + Operator description + + + Table Spool + Operator name + + + Stores the data from the input into a temporary table in order to optimize rewinds. + Operator description + + + Index Spool + Operator name + + + Reformats the data from the input into a temporary index, which is then used for seeking with the supplied seek predicate. + Operator description + + + Table Update + Operator name + + + Update input rows in the table specified in the Argument field. + Operator description + + + Table Insert + Operator name + + + Insert input rows into the table specified in Argument field. + Operator description + + + Table Delete + Operator name + + + Delete input rows from the table specified in Argument field. + Operator description + + + Table Merge + Operator name + + + Merge input rows in the table specified in Argument field. + Operator description + + + Index Update + Operator name + + + Update rows in an index. + Operator description + + + Index Insert + Operator name + + + Insert rows into an index. + Operator description + + + Index Delete + Operator name + + + Delete rows from index. + Operator description + + + Clustered Index Update + Operator name + + + Update rows in a clustered index. + Operator description + + + Clustered Index Insert + Operator name + + + Insert rows in a clustered index. + Operator description + + + Clustered Index Merge + Operator name + + + Merge rows in a clustered index. + Operator description + + + Clustered Index Delete + Operator name + + + Delete rows from a clustered index. + Operator description + + + Top + Operator name + + + Select the first few rows based on a sort order. + Operator description + + + Bitmap + Operator name + + + Bitmap. + Operator description + + + UDX + Operator name + + + UDX. + Operator description + + + Window Spool + Show plan's Window node property + + + Expands each row into the set of rows that represent the window associated with it. + Show plan's Window node property description + + + Window Aggregate + Show plan's Window Aggregate node property + + + Computes values of functions across the windows defined by the OVER clause. Input rowset is suitably sorted stream. + Show plan's Window Aggregate node property description + + + Batch Hash Table Build + Operator name + + + Batch Hash Table Build. + Operator description + + + Switch + Operator name + + + Switch. + Operator description + + + Predict + Operator name + + + Applies a trained machine learning model to input data + Operator description + + + Table Valued Function + Operator name + + + Table valued function. + Operator description + + + Aggregate + Operator name + + + Calculates an expression containing SUM, COUNT, MIN, MAX, or AVG. + Operator description + + + Arithmetic Expression + Operator name + + + Computes a new value from existing values in a row. + Operator description + + + Delete + Operator name + + + Removes the specified rows from the specified table. + Operator description + + + Insert + Operator name + + + Adds a row to table. + Operator description + + + Locate + Operator name + + + Fetching a full row from a heap or a clustered index. + Operator description + + + Spool + Operator name + + + Saving temporarily an intermediate query result. + Operator description + + + SQL + Operator name + + + SQL. + Operator description + + + Update + Operator name + + + Modify the values in the specified table. + Operator description + + + Assign + Operator name + + + Validate referential integrity constraints. + Operator description + + + Convert + Operator name + + + Implicit or explicit conversion of one scalar datatype to another. + Operator description + + + Declare + Operator name + + + Allocates a local variable. + Operator description + + + If + Operator name + + + Conditional processing based on an expression. + Operator description + + + Intrinsic + Operator name + + + Invokes an internal Transact-SQL function. + Operator description + + + Set Function + Operator name + + + Set Function. + Operator description + + + Dynamic + Operator name + + + Cursor that can see all changes made by others. + Operator description + + + Fetch Query + Operator name + + + The query used to retrieve rows when a fetch is issued against a cursor. + Operator description + + + Fast Forward + Operator name + + + Fast Forward. + Operator description + + + Keyset + Operator name + + + Cursor that can see updates made by others, but not inserts. + Operator description + + + Population Query + Operator name + + + The query used to populate a cursor's work table when the cursor is opened. + Operator description + + + Refresh Query + Operator name + + + Fetches current data for rows in fetch buffer. + Operator description + + + Snapshot + Operator name + + + A cursor that does not see changes made by others. + Operator description + + + RID Lookup + Operator name + + + RID Lookup + Operator description + + + Key Lookup + Operator name + + + Uses a supplied clustering key to lookup on a table that has a clustered index. + Operator description + + + Key Lookup + Operator name + + + Adaptive Join + Operator name + + + Chooses dynamically between hash join and nested loops. + Operator description + + + Foreign Key References Check + Operator name + + + Checks referential integrity of the delete operation. + Operator description + + + Apply + Operator name + + + Apply opration. + Operator description + + + Broadcast + Operator name + + + Broadcast data movement. + Operator description + + + Compute To Control Node + Operator name + + + Data flow from compute nodes to control node. + Operator description + + + Constant Table Get + Operator name + + + Get tuples from contant table. + Operator description + + + Control To Compute Nodes + Operator name + + + Data flow from control node to compute nodes. + Operator description + + + External Broadcast + Operator name + + + Broadcast data movement for external table. + Operator description + + + External Export + Operator name + + + Export data movement for external table. + Operator description + + + External Local Streaming + Operator name + + + Streaming data movement between external table and local table. + Operator description + + + External RoundRobin + Operator name + + + RoundRobin data movement for external table. + Operator description + + + External Shuffle + Operator name + + + Shuffle data movement for external table. + Operator description + + + Get + Operator name + + + Get tuples from table. + Operator description + + + Group by and Apply + Operator name + + + Group by and Apply. + Operator description + + + Group by Aggregates + Operator name + + + Group by aggregates. + Operator description + + + Join + Operator name + + + Join tables. + Operator description + + + Rollup Aggregate + Operator name + + + This represents a ROLLUP operator or a CUBE operator. + Operator description + + + Project + Operator name + + + Project columns. + Operator description + + + Shuffle + Operator name + + + Shuffle data movement. + Operator description + + + Single Source RoundRobin + Operator name + + + Single Source RoundRobin data movement. + Operator description + + + Single Source Shuffle + Operator name + + + Single Source Shuffle data movement. + Operator description + + + Trim + Operator name + + + Trim data. + Operator description + + + Union + Operator name + + + Union tables. + Operator description + + + Union All + Operator name + + + Union All tables. + Operator description + + + {0}: {1} + Format for name / value pair - {0} is property name, {1} is property value. + Parameters: 0 - name (string), 1 - value (string) + + + {0} B + Size in Bytes format + + + {0} KB + Size in KiloBytes format + + + {0} MB + Size in Bytes format + + + {0} GB + Size in GigaBytes format + + + {0} TB + Size in TeraBytes format + diff --git a/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.strings b/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.strings index d5e81b3f..616fb167 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.strings +++ b/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.strings @@ -854,4 +854,1362 @@ SqlAssessmentUnsuppoertedEdition(int editionCode) = Unsupported engine edition { # Azure Functions CouldntFindAzureFunction(string functionName, string fileName) = Couldn't find Azure function with FunctionName '{0}' in {1} MoreThanOneAzureFunctionWithName(string functionName, string fileName) = More than one Azure function found with the FunctionName '{0}' in {1} -SqlBindingsNet5NotSupported = Adding SQL bindings is not supported for .NET 5 \ No newline at end of file +SqlBindingsNet5NotSupported = Adding SQL bindings is not supported for .NET 5 + + +############################################################################ +# Show Plan + +; Statement +Statement = Statement +; Statement description +StatementDesc = In most cases, contains the text of the Transact-SQL statement. For rows of type PLAN_ROW, contains a description of the operation. +; Physical Operation +PhysicalOperation = Physical Operation +; Physical Operation description +PhysicalOperationDesc = Physical implementation algorithm for the node. For rows of type PLAN_ROWS only. +; Logical Operation +LogicalOperation = Logical Operation +; Logical Operation description +LogicalOperationDesc = Relational algebraic operator this node represents. For rows of type PLAN_ROWS only. +; Operation description. Short +OperationDescriptionShort = Description +; Operation description +OperationDescription = Operation description. +; Operation Argument. Short +OperationArgumentShort = Argument +; Operation Argument description +OperationArgumentDescription = Provides supplemental information about the operation being performed. The contents of this column depend on the physical operator. +; Object field +ObjectShort = Object +; Object field description +ObjectDescription = Object. +; IndexKind field +IndexKind = Index Kind +; IndexKind field description +IndexKindDescription = Type of index for the referenced object. +; Defined Values +DefinedValues = Defined Values +; Defined Values description +DefinedValuesDescription = Contains a comma-separated list of values introduced by this operator, which may be computed expressions present in the current query, or internal values introduced by the query processor in order to process this query. For rows of type PLAN_ROWS only. +; Output List +OutputList = Output List +; Output List +OutputListDescription = Contains a comma-separated list of columns being projected by the current operation. +; Warnings +Warnings = Warnings +; Warnings description +WarningsDescription = Contains a comma-separated list of warning messages relating to the current operation. Warning messages may include the string 'NO STATS:()' with a list of columns. +; Parallel +Parallel = Parallel +; Parallel description +ParallelDescription = Whether the operator is running in parallel. +; Estimated Number of Rows Per Execution +EstimatedNumberOfRowsPerExecution = Estimated Number of Rows Per Execution +; Estimated Number of Rows Per Execution description +EstimatedNumberOfRowsPerExecutionDescription = Estimated number of rows per execution output by this operator. This is for PLAN_ROWS only. +; Estimated Number of Rows for All Executions +EstimatedNumberOfRowsForAllExecutions = Estimated Number of Rows for All Executions +; Estimated Number of Rows for All Executions description +EstimatedNumberOfRowsForAllExecutionsDescription = Estimated number of rows for all executions output by this operator. This is for PLAN_ROWS only. +; Estimated Rows Read +EstimatedRowsRead = Estimated Number of Rows to be Read +; Estimated Rows Read description +EstimatedRowsReadDescription = Number of rows estimated to be read by this operator. This value may differ from "Estimated Number of Rows for All Executions" if the operator has a predicate. +; GraphDB Transitive Closure +IsGraphDBTransitiveClosure = Is GraphDB Transitive Closure +; GraphDB Transitive Closure Description +IsGraphDBTransitiveClosureDescription = Whether the sequence represents a GraphDB transitive closure. +; Interleaved Executed +IsInterleavedExecuted = IsInterleavedExecuted +; Interleaved Executed Description +IsInterleavedExecutedDescription = Whether the operator is interleaved executed. +; Is Adaptive +IsAdaptive = Is Adaptive +; Is Adaptive description +IsAdaptiveDescription = Whether the operator is adaptive. +; Adaptive Threshold Rows +AdaptiveThresholdRows = Adaptive Threshold Rows +; Adaptive Threshold Rows description +AdaptiveThresholdRowsDescription = If this is an adaptive operator, the cardinality at which it adapts. +; Estimated Join Type +EstimatedJoinType = Estimated Join Type +; Estimated Join Type description +EstimatedJoinTypeDescription = The join type (nested loops or hash join) estimated by the query optimizer before adapting. +; Actual Join Type +ActualJoinType = Actual Join Type +; Actual Join Type Description +ActualJoinTypeDescription = The actual join picked (nested loops or hash join) as part of adaptive join execution. +; Estimated Row Size +EstimatedRowSize = Estimated Row Size +; Estimated Row Size description +EstimatedRowSizeDescription = Estimated average row size of the row being passed through this operator. +; Estimated IO Cost +EstimatedIoCost = Estimated I/O Cost +; Estimated IO Cost description +EstimatedIoCostDescription = Estimated I/O cost for this operator. For rows of type PLAN_ROWS only. +; Estimated CPU Cost +EstimatedCpuCost = Estimated CPU Cost +; Estimated CPU Cost description +EstimatedCpuCostDescription = Estimated CPU cost for this operator. For rows of type PLAN_ROWS only. +; Estimated Number of Executions +EstimatedNumberOfExecutions = Estimated Number of Executions +; Estimated Number of Executions description +EstimatedNumberOfExecutionsDescription = Estimated number of times this operator will be executed while running the current query. +; Show plan node property name +EstimatedOperatorCost = Estimated Operator Cost +; Estimated Costs description +EstimatedOperatorCostDescription = Estimated cost of this operator. +; Estimated Subtree Cost +EstimatedSubtreeCost = Estimated Subtree Cost +; Estimated Subtree Cost description +EstimatedSubtreeCostDescription = Estimated cumulative cost of this operation and all child operations. +; Number of Rows +NumberOfRows = Actual Number of Rows for All Executions +; Number of Rows description +NumberOfRowsDescription = Actual number of rows for All Executions output by this operator. For rows of type PLAN_ROWS only. +; Number of Rows Read by a Rowset (Table or Index) +ActualRowsRead = Number of Rows Read +; Number of Rows Read by a Rowset (Table or Index) Description +ActualRowsReadDescription = Number of rows read from a table or an index prior to applying a predicate filter. For rows of type PLAN_ROWS only. +; Number of Batches +NumberOfBatches = Actual Number of Batches +; Number of Batches description +NumberOfBatchesDescription = Actual number of Batches output by this operator. +; Number of Executions +NumberOfExecutions = Number of Executions +; Number of Executions description +NumberOfExecutionsDescription = Number of times this operator will be executed while running the current query. +; Estimated Data Size +EstimatedDataSize = Estimated Data Size +; Estimated Data Size description +EstimatedDataSizeDescription = Estimated data size of the data being passed through this operator. +; Show plan's simple root node property +ParameterList = Parameter List +; Show plan's simple root node property description +ParameterListDescription = Parameter list. +; Show plan's simple root node property +MemoryFractions = Memory Fractions +; Show plan's simple root node property description +MemoryFractionsDescription = Memory fractions. +; Show plan's simple root node property +MemoryFractionsInput = Memory Fractions Input +; Show plan's simple root node property description +MemoryFractionsInputDescription = Memory fractions input. +; Show plan's simple root node property +MemoryFractionsOutput = Memory Fractions Output +; Show plan's simple root node property description +MemoryFractionsOutputDescription = Memory fractions output. +; Show plan's UDX node property +UdxName = Name +; Show plan's UDX node property description +UdxNameDescription = Name. +; Show plan's ConstantScan node property +Values = Values +; Show plan's ConstantScan node property description +ValuesDescription = Values. +; CachedPlanSize property +CachedPlanSize = Cached plan size +; Description for CachedPlanSize property +CachedPlanSizeDescription = Cached plan size. +; UsePlan property +UsePlan = Use plan +; InlineScalarTsqlUdf property +ContainsInlineScalarTsqlUdfs = Contains Inline Scalar Tsql Udfs +; DegreeOfParallelism property +DegreeOfParallelism = Degree of Parallelism +; Description for DegreeOfParallelism property +DegreeOfParallelismDescription = Degree of parallelism. +; EffectiveDegreeOfParallelism property +EffectiveDegreeOfParallelism = Effective Degree of Parallelism +; Description for EffectiveDegreeOfParallelism property +EffectiveDegreeOfParallelismDescription = Max degree of parallelism during columnstore index build. +; Root node for show plan property +MemoryGrant = Memory Grant +; Description for MemoryGrant property +MemoryGrantDescription = Memory grant. +; Show plan node property +RemoteDestination = Remote Destination +; Show plan node property description +RemoteDestinationDescription = Remote object. +; Show plan node property +RemoteObject = Remote Object +; Show plan node property description +RemoteObjectDescription = Remote object. +; Show plan node property +RemoteSource = Remote Source +; Show plan node property description +RemoteSourceDescription = Remote source. +; Show plan node property +UsedUdxColumns = Used UDX Columns +; Show plan node property description +UsedUdxColumnsDescription = Used UDX columns. +; Show plan node property +InnerSideJoinColumns = Inner Side Join columns +; Show plan node property description +InnerSideJoinColumnsDescription = Inner side join columns. +; Show plan node property +OuterSideJoinColumns = Outer Side Join columns +; Show plan node property description +OuterSideJoinColumnsDescription = Outer side join columns. +; Show plan node property +WhereJoinColumns = Where (join columns) +; Show plan node property +Residual = Residual +; Show plan node property description +ResidualDescription = Residual. +; Show plan node property +PassThru = Pass Through +; Show plan node property description +PassThruDescription = Pass throuh. +; Show plan node property +ManyToMany = Many to Many +; Show plan node property description +ManyToManyDescription = Many to many. +; Show plan node property +PartitionColumns = Partition Columns +; Show plan node property description +PartitionColumnsDescription = Partition columns. +; Column sort type +Ascending = Ascending +; Column sort type +Descending = Descending +; Show plan node property +HashKeys = Hash Keys +; Show plan node property description +HashKeysDescription = Hash keys. +; Show plan node property +ProbeColumn = Probe Column +; Show plan node property description +ProbeColumnDescription = Probe column. +; Show plan node property +PartitioningType = Partitioning Type +; Show plan node property description +PartitioningTypeDescription = Partitioning type. +; Show plan node property +GroupBy = Group By +; Show plan node property description +GroupByDescription = Group by. +; Show plan node property +GroupingSets = Grouping Sets +; Show plan node property description +GroupingSetsDescription = The group sets list. Each Value is a reverse bit map for the grouping columns in Group By property. +; Show plan node property +SegmentColumn = Segment Column +; Show plan node property description +SegmentColumnDescription = Segment column. +; Show plan node property +RankColumns = Rank Columns +; Show plan node property description +RankColumnsDescription = Rank columns. +; Show plan node property +Predicate = Predicate +; Show plan node property description +PredicateDescription = Predicate. +; Show plan node property +OuterReferences = Outer References +; Show plan node property description +OuterReferencesDescription = Outer references. +; Show plan node property +ScalarOperator = Scalar Operator +; Show plan node property +ActionColumn = Action Column +; Show plan node property description +ActionColumnDescription = Action column. +; Show plan node property +OriginalActionColumn = Original Action Column +; Show plan node property description +OriginalActionColumnDescription = Original Action column. +; Show plan node property +Rows = Top Rows +; Show plan node property description +RowsDescription = Top Rows. +; Show plan node property +SeekPredicate = Seek Predicate +; Show plan node property description +SeekPredicateDescription = Seek predicate. +; Show plan node property +Partitioned = Partitioned +; Show plan node property description +PartitionedDescription = Whether the operation is on a partitioned table or index. +; Show plan node property +SeekKeys = Seek Keys +; Show plan node property description +SeekKeysDescription = Keys used by a seek operation. +; Show plan node property +PartitionsAccessed = Actual Partitions Accessed +; Show plan node property +PartitionCount = Actual Partition Count +; Show plan node property +TieColumns = Tie Columns +; Show plan node property description +TieColumnsDescription = Tie columns. +; Show plan node property +IsPercent = Is Percent +; Show plan node property description +IsPercentDescription = Is percent. +; Show plan node property +WithTies = With Ties +; Show plan node property description +WithTiesDescription = With ties. +; Show plan node property +PartitionId = Partition ID +; Show plan node property description +PartitionIdDescription = Partition ID. +; Show plan node property +Ordered = Ordered +; Show plan node property description +OrderedDescription = Ordered. +; ScanDirection property +ScanDirection = Scan Direction +;ScanDirection property description +ScanDirectionDescription = Direction of the scan operation as either forward or backward. +; Show plan node property +ForcedIndex = Forced Index +; Show plan node property description +ForcedIndexDescription = Forced index. +; Show plan node property +SetPredicate = Predicate +; Show plan node property description +SetPredicateDescription = Predicate +; Show plan node property +TopExpression = Top Expression +; Show plan node property description +TopExpressionDescription = Top expression. +; Show plan node property +HashKeysBuild = Hash Keys Build +; Show plan node property description +HashKeysBuildDescription = Hash keys build. +; Show plan node property +HashKeysProbe = Hash Keys Probe +; Show plan node property description +HashKeysProbeDescription = Hash keys probe. +; Show plan node property +BuildResidual = Build Residual +; Show plan node property description +BuildResidualDescription = Build residual. +; Show plan node property +ProbeResidual = Probe Residual +; Show plan node property description +ProbeResidualDescription = Probe residual. +; Show plan node property +SeekPredicates = Seek Predicates +; Show plan node property description +SeekPredicatesDescription = Seek predicates. +; Set options property in show plan +SetOptions = Set Options +; Set options property in show plan description +SetOptionsDescription = Set options. +; Optimization Level property in show plan +OptimizationLevel = Optimization Level +; Optimization Level property in show plan description +OptimizationLevelDescription = Optimization level. +; StatementOptmEarlyAbortReason property +StatementOptmEarlyAbortReason = Reason For Early Termination Of Statement Optimization +; StatementOptmEarlyAbortReason property value +TimeOut = Time Out +; StatementOptmEarlyAbortReason property value +MemoryLimitExceeded = Memory Limit Exceeded +; StatementOptmEarlyAbortReason property value +GoodEnoughPlanFound = Good Enough Plan Found +; Estimated Rebinds +EstimatedRebinds = Estimated Rebinds +; Estimated Rebinds Description +EstimatedRebindsDescription = Estimated rebinds. +; Estimated Rewinds +EstimatedRewinds = Estimated Rewinds +; Estimated Rewinds Description +EstimatedRewindsDescription = Estimated rewinds. +; Actual Locally Aggregated Rows +ActualLocallyAggregatedRows = Actual Number of Locally Aggregated Rows +; Actual Locally Aggregated Rows Description +ActualLocallyAggregatedRowsDescription = Actual number of locally aggregated rows +; Actual Rebinds +ActualRebinds = Actual Rebinds +; Actual Rebinds Description +ActualRebindsDescription = Actual Rebinds. +; Actual Rewinds +ActualRewinds = Actual Rewinds +; Actual Rewinds Description +ActualRewindsDescription = Actual Rewinds. +; Actual I/O Statistics +ActualIOStatistics = Actual I/O Statistics +; Actual I/O Statistics Description +ActualIOStatisticsDescription = Actual I/O Statistics +; Actual Time Statistics +ActualTimeStatistics = Actual Time Statistics +; Actual Time Statistics Description +ActualTimeStatisticsDescription = Actual Time Statistics +; Actual Elapsed Milliseconds +ActualElapsedms = Actual Elapsed Time (ms) +; Actual Elapsed Milliseconds Description +ActualElapsedmsDescription = Actual elapsed time in milliseconds +; Actual CPU Time Milliseconds +ActualCPUms = Actual Elapsed CPU Time (ms) +; Actual CPU Time Milliseconds Description +ActualCPUmsDescription = Actual elapsed CPU time in milliseconds +; Actual Scans +ActualScans = Actual Scans +; Actual Scans Description +ActualScansDescription = Actual Scans +; Actual Logical Reads +ActualLogicalReads = Actual Logical Reads +; Actual Logical Reads Description +ActualLogicalReadsDescription = Actual Logical Reads +; Actual Physical Reads +ActualPhysicalReads = Actual Physical Reads +; Actual Physical Reads Description +ActualPhysicalReadsDescription = Actual Physical Reads +; Actual Page Server Reads +ActualPageServerReads = Actual Page Server Reads +; Actual Page Server Reads Description +ActualPageServerReadsDescription = Actual Page Server Reads +; Actual Read Aheads +ActualReadAheads = Actual Read Aheads +; Actual Read Aheads Description +ActualReadAheadsDescription = Actual Read Aheads +; Actual Page Server Read Aheads +ActualPageServerReadAheads = Actual Page Server Read Aheads +; Actual Page Server Read Aheads Description +ActualPageServerReadAheadsDescription = Actual Page Server Read Aheads +; Actual Lob Logical Reads +ActualLobLogicalReads = Actual Lob Logical Reads +; Actual Lob Logical Reads Description +ActualLobLogicalReadsDescription = Actual Lob Logical Reads +; Actual Lob Physical Reads +ActualLobPhysicalReads = Actual Lob Physical Reads +; Actual Lob Physical Reads Description +ActualLobPhysicalReadsDescription = Actual Lob Physical Reads +; Actual Lob Page Server Reads +ActualLobPageServerReads = Actual Lob Page Server Reads +; Actual Lob Page Server Reads Description +ActualLobPageServerReadsDescription = Actual Lob Page Server Reads +; Actual Lob Read Aheads +ActualLobReadAheads = Actual Lob Read Aheads +; Actual Lob Read Aheads Description +ActualLobReadAheadsDescription = Actual Lob Read Aheads +; Actual Lob Page Server Read Aheads +ActualLobPageServerReadAheads = Actual Lob Page Server Read Aheads +; Actual Lob Page Server Read Aheads Description +ActualLobPageServerReadAheadsDescription = Actual Lob Page Server Read Aheads +; ActualMemoryGrantStats +ActualMemoryGrantStats = Memory Usage +; Hpc Row Count +HpcRowCount = Hpc Row Count +; Hpc Row Count Description +HpcRowCountDescription = Number of rows processed by Hpc devices. +; Hpc Kernel Elapsed Us +HpcKernelElapsedUs = Hpc Kernel Elapsed Time in Us +; Hpc Kernel Elapsed Us Description +HpcKernelElapsedUsDescription = Elapsed time (in micro seconds) of Hpc device kernel execution. +; Hpc Host To Device Bytes +HpcHostToDeviceBytes = Hpc Host To Device Bytes +; Hpc Host To Device Bytes Description +HpcHostToDeviceBytesDescription = Data transferred from host to Hpc device in bytes. +; Hpc Device To Host Bytes +HpcDeviceToHostBytes = Hpc Device To Host Bytes +; Hpc Device To Host Bytes Description +HpcDeviceToHostBytesDescription = Data transferred from Hpc device to host in bytes. +; InputMemoryGrant +InputMemoryGrant = Input Memory +; OutputMemoryGrant +OutputMemoryGrant = Output Memory +; UsedMemoryGrant +UsedMemoryGrant = Used Memory +; Distinct +Distinct = Distinct +; Distinct description +DistinctDescription = Distinct. +; OrderBy +OrderBy = Order By +; OrderBy description +OrderByDescription = Order by. +SpillOccurredDisplayString = Operator used tempdb to spill data during execution +; ColumnsWithNoStatistics property +ColumnsWithNoStatistics = Columns With No Statistics +; ColumnsWithNoStatistics property description +ColumnsWithNoStatisticsDescription = Columns with no statistics warning. +; NoJoinPredicate property +NoJoinPredicate = No Join Predicate +; NoJoinPredicate property description +NoJoinPredicateDescription = No Join predicate warning. +; SpillToTempDbOld property +SpillToTempDbOld = Operator used tempdb to spill data during execution with spill level {0} +; SpillToTempDb property +SpillToTempDb = Operator used tempdb to spill data during execution with spill level {0} and {1} spilled thread(s) +; SpillToTempDb property description +SpillToTempDbDescription = Spill to tempdb warning. +; SortSpillDetails property +SortSpillDetails = Sort wrote {0} pages to and read {1} pages from tempdb with granted memory {2}KB and used memory {3}KB +; SortSpillDetails property description +SortSpillDetailsDescription = Details of sort spill +; HashSpillDetails property +HashSpillDetails = Hash wrote {0} pages to and read {1} pages from tempdb with granted memory {2}KB and used memory {3}KB +; HahSpillDetails property description +HashSpillDetailsDescription = Details of hash spill +; FullUpdateForOnlineIndexBuild property +FullUpdateForOnlineIndexBuild = A partial update was converted to a full update because of an online index build +; FullUpdateForOnlineIndexBuild property description +FullUpdateForOnlineIndexBuildDescription = Full update for online index build warning +; Wait property +Wait = The query had to wait {0} seconds for {1} during execution +; Wait property description +WaitDescription = Query wait warning. +; PlanAffectingConvert property +PlanAffectingConvert = Type conversion in expression ({0}) may affect "{1}" in query plan choice +; PlanAffectingConvert property description +PlanAffectingConvertDescription = Plan-affecting type conversion warning. +; MemoryGrantWarning property +MemoryGrantWarning = The query memory grant detected "{0}", which may impact the reliability. Grant size: Initial {1} KB, Final {2} KB, Used {3} KB. +;MemoryGrantWarning property description +MemoryGrantWarningDescription = Details on memory grant warning +; StartupExpression property +StartupExpression = Startup Expression +; StartupExpression property description +StartupExpressionDescription = Whether a filter startup expression is used. +; StartupExpressionPredicate property +StartupExpressionPredicate = Startup Expression Predicate +; Query property +Query = Query +; Stack property +Stack = With Stack +; RowCount property +RowCount = Is Row Count +; Optimized property +Optimized = Optimized +; WithPrefetch property +WithPrefetch = With Prefetch +; Prefix property +Prefix = Prefix +; StartRange property +StartRange = Start +; StartRange property description +StartRangeDescription = Start of the range. +; EndRange property +EndRange = End +; EndRange property description +EndRangeDescription = End of the range. +; RangeColumns property +RangeColumns = Range Columns +; RangeExpressions property +RangeExpressions = Range Expressions +; ScanType property +ScanType = Scan Type +; ColumnReference property +ColumnReference = Column Reference +; Server property +ObjectServer = Server +; Server property description +ObjectServerDescription = Server name for the referenced object. +; Database property +ObjectDatabase = Database +; Database property description +ObjectDatabaseDescription = Database name for the referenced object. +; Index property +ObjectIndex = Index +; Index property description +ObjectIndexDescription = Index name for the referenced object. +; Schema property +ObjectSchema = Schema +; Schema property description +ObjectSchemaDescription = Schema name for the referenced object. +; Table property +ObjectTable = Table +; Table property description +ObjectTableDescription = Table name for the referenced object. +; Alias property +ObjectAlias = Alias +; Alias property description +ObjectAliasDescription = Alias used for the referenced object. +; Column property +ObjectColumn = Column +; Column property description +ObjectColumnDescription = Column name for the referenced object. +; ComputedColumn property +ObjectComputedColumn = Computed Column +; ComputedColumn property description +ObjectComputedColumnDescription = Whether this is a computed column. +; ParameterDataType property +ParameterDataType = Parameter Data Type +; ParameterCompiledValue property +ParameterCompiledValue = Parameter Compiled Value +; ParameterRuntimeValue property +ParameterRuntimeValue = Parameter Runtime Value +; CursorPlan property +CursorPlan = Cursor Plan +; CursorOperation property +CursorOperation = Cursor Operation +; CursorName property +CursorName = Cursor Name +; CursorActualType property +CursorActualType = Cursor Actual Type +; CursorRequestedType property +CursorRequestedType = Cursor Requested Type +; CursorConcurrency property +CursorConcurrency = Cursor Concurrency +; ForwardOnly property +ForwardOnly = Forward Only +; QueryPlan property +QueryPlan = Query Plan +; OperationType property +OperationType = Operation Type +; Node ID property +NodeId = Node ID +; Primary Node ID property +PrimaryNodeId = Primary Node ID +; Internal Info property +InternalInfo = Internal Debugging Information +; Foreign Key References Count property +ForeignKeyReferencesCount = Foreign Key References Count +; No Matching Index Count property +NoMatchingIndexCount = No Matching Indexes Count +; Partial Matching Index Count property +PartialMatchingIndexCount = Partial Matching Indexes Count +; Logical operator +LogicalOpCollapse = Collapse +; Logical operator +LogicalOpConcatenation = Concatenation +; Logical operator +LogicalOpConstantScan = Constant Scan +; Logical operator +LogicalOpGatherStreams = Gather Streams +; Logical operator +LogicalOpRepartitionStreams = Repartition Streams +; Logical operator +LogicalOpDistributeStreams = Distribute Streams +; Logical operator +LogicalOpFilter = Filter +; Logical operator +LogicalOpAssert = Assert +; Logical operator +LogicalOpLogRowScan = Log Row Scan +; Logical operator +LogicalOpPrint = Print +; Logical operator +LogicalOpComputeScalar = Compute Scalar +; Logical operator +LogicalOpMergeInterval = Merge Interval +; Logical operator +LogicalOpRank = Rank +; Logical operator +LogicalOpSegment = Segment +; Logical operator +LogicalOpSequence = Sequence +; Logical operator +LogicalOpSplit = Split +; Logical operator +LogicalOpAggregate = Aggregate +; Logical operator +LogicalOpTableScan = Table Scan +; Logical operator +LogicalOpClusteredIndexScan = Clustered Index Scan +; Logical operator +LogicalOpClusteredIndexSeek = Clustered Index Seek +; Logical operator +LogicalOpDeletedScan = Deleted Scan +; Logical operator +LogicalOpInsertedScan = Inserted Scan +; Logical operator +LogicalOpParameterTableScan = Parameter Table Scan +; Logical operator +LogicalOpPut = Put +; Logical operator +LogicalOpIndexScan = Index Scan +; Logical operator +LogicalOpIndexSeek = Index Seek +; Logical operator +LogicalOpRemoteScan = Remote Scan +; Logical operator +LogicalOpRemoteIndexScan = Remote Index Scan +; Logical operator +LogicalOpRemoteIndexSeek = Remote Index Seek +; Logical operator +LogicalOpRemoteQuery = Remote Query +; Logical operator +LogicalOpRemoteInsert = Remote Insert +; Logical operator +LogicalOpRemoteUpdate = Remote Update +; Logical operator +LogicalOpRemoteDelete = Remote Delete +; Logical operator +LogicalOpClusteredUpdate = Clustered Update +; Logical operator +LogicalOpDistinctSort = Distinct Sort +; Logical operator +LogicalOpSort = Sort +; Logical operator +LogicalOpTopNSort = Top N Sort +; Logical operator +LogicalOpEagerSpool = Eager Spool +; Logical operator +LogicalOpLazySpool = Lazy Spool +; Logical operator +LogicalOpUpdate = Update +; Logical operator +LogicalOpInsert = Insert +; Logical operator +LogicalOpDelete = Delete +; Logical operator +LogicalOpMerge = Merge +; Logical operator +LogicalOpTop = Top +; Logical operator +LogicalOpDistinct = Distinct +; Logical operator +LogicalOpFlowDistinct = Flow Distinct +; Logical operator +LogicalOpPartialAggregate = Partial Aggregate +; Logical operator +LogicalOpInnerApply = Inner Apply +; Logical operator +LogicalOpInnerJoin = Inner Join +; Logical operator +LogicalOpLeftAntiSemiApply = Left Anti Semi Apply +; Logical operator +LogicalOpLeftSemiApply = Left Semi Apply +; Logical operator +LogicalOpLeftOuterApply = Left Outer Apply +; Logical operator +LogicalOpLeftOuterJoin = Left Outer Join +; Logical operator +LogicalOpRightOuterJoin = Right Outer Join +; Logical operator +LogicalOpFullOuterJoin = Full Outer Join +; Logical operator +LogicalOpLeftSemiJoin = Left Semi Join +; Logical operator +LogicalOpLeftAntiSemiJoin = Left Anti Semi Join +; Logical operator +LogicalOpRightSemiJoin = Right Semi Join +; Logical operator +LogicalOpRightAntiSemiJoin = Right Anti Semi Join +; Logical operator +LogicalOpIntersect = Intersect +; Logical operator +LogicalOpIntersectAll = Intersect All +; Logical operator +LogicalOpUnion = Union +; Logical operator +LogicalOpLeftDiff = Left Diff +; Logical operator +LogicalOpLeftDiffAll = Left Diff All +; Logical operator +LogicalOpRightDiff = Right Diff +; Logical operator +LogicalOpRightDiffAll = Right Diff All +; Logical operator +LogicalOpAntiDiff = Anti Diff +; Logical operator +LogicalOpCrossJoin = Cross Join +; Logical operator +LogicalOpBitmapCreate = Bitmap Create +; Logical operator +LogicalOpUDX = UDX +; Logical operator +LogicalOpWindow = Window Spool +; Logical operator +LogicalOpSwitch = Switch +; Logical operator +LogicalOpMergeStats = Merge Stats +; Logical operator +LogicalOpLocalStats = Local Stats +; Logical operator +LogicalOpTableValuedFunction = Table Valued Function +; Logical operator +LogicalOpBatchHashTableBuild = Batch Hash Table Build +; Logical operator +LogicalOpForeignKeyReferencesCheck = Foreign Key References Check +; RIDLookup operator +LogicalOpRIDLookup = RID Lookup +; StoredProc node +StoredProc = Stored Procedure +; UDF node +Udf = UDF +; ProcName property +ProcName = Procedure Name +; Storage property +Storage = Storage +; Storage property +StorageDesc = Storage +; ActualExectionMode property +ActualExecMode = Actual Execution Mode +ActualExecModeDesc = Actual Execution Mode +; EstimatedExecutionMode property +EstimatedExecMode = Estimated Execution Mode +EstimatedExecModeDesc = Estimated Execution Mode +;"Cost: {0} percent" String to format +CostFormat(int x) = Cost: {0} % +; Remote Data Access +RemoteDataAccess = Remote Data Access +RemoteDataAccessDescription = Whether the operator uses remote procedure call (RPC) to access remote data. +; Clone Access Scope +CloneAccessScope = Clone Access Scope +CloneAccessScopeDescription = Clones that the operator may access. +PrimaryClones = Primary Clones +SecondaryClones = Secondary Clones +BothClones = All Clones +EitherClones = Primary Or Secondary Clones +ExactMatchClones = Single Clone Match +; Remoting for remote exchange operator +Remoting = Remoting +RemotingDescription = Whether the operator can run remotely. +; Activation +Activation = Activation +; Brick Routing +BrickRouting = Brick Routing +FragmentIdColumn = Fragment Id Column +; Showplan edit query text button +EditQueryText = Edit Query Text from Showplan XML (possibly truncated) +; error message when the ShowPlan source cannot be recognized +UnknownShowPlanSource = Execution plan source type can not be recognized. +; Save plan dialog filter string +SavePlanFilter = Sql Plan files (*.SqlPlan)|*.SqlPlan|All files (*.*)|*.* +; Message box if user tries to save in XML show plan from Shiloh or Sphinx +NoXmlPlanData = Plan data is not available in XML format. Only plans from SQL Server Yukon can be saved. +; Description of a per thread counter +PerThreadCounterDescription = Per-thread counter information. +; Runtime counter property name +RuntimeCounterThread(int index) = Thread {0} +; Runtime counter property name. Thread on Instance. +RuntimeCounterThreadOnInstance(int thread, int instance) = Thread {0} on Instance {1} +; Runtime counter property name +RuntimeCounterThreadAll = All threads +; label for Connection Properties hyperlink +ConnectionPropertiesLabel = View connection properties +; Error when displaying show plan properties +UnknownAssignType = Unknown assign type. +; exception message box caption +MessageBoxCaption = SQL Server +; Message shown when user enters wrong zoom level +ZoomLevelShouldBeBetween(int minimum, int maximum) = Zoom level must be an integer value between {0} and {1}. +; Exception thrown when node type is unknown +UnknownNodeType = Unknown node type. +; Exception thrown by show plan when it gets unknown type of cursor plan operation +UnknownCursorPlanOperation(string name) = Unknown cursor plan operation '{0}'. +; Exception thrown by show plan when it gets unknown statement type +UnknownStatementType = Statement type is not recognized. +; Show plan node property +RollupInfo = Rollup Information +; Show plan node property description +RollupInfoDescription = Rollup information. +; Show plan node property +HighestLevel = Highest Level +; Show plan node property description +HighestLevelDescription = The highest level of grouping attributes computed in this rollup. +; Show plan node property +RollupLevel = Rollup Levels +; Show plan node property description +RollupLevelDescription = All levels of grouping attributes computed in this rollup. +; Show plan node property +Level = Level +; Show plan node property description +LevelDescription = A level of grouping attributes computed in this rollup. + +# +# Operators +# +; Unkown (reused string, unkown operator, or unkown reason, or unknown ...) +Unknown = Unknown +; Operator description +UnknownDescription = Unknown operator. +; Operator name +Result = Result +; Operator description +ResultDescription = Result. +; Operator name +Collapse = Collapse +; Operator description +CollapseDescription = Groups an insert and delete on the same value into an update within wide update plans. +; Operator name +Concatenation = Concatenation +; Operator description +ConcatenationDescription = Append multiple input tables to form the output table. +; Operator name +ConstantScan = Constant Scan +; Operator description +ConstantScanDescription = Scan an internal table of constants. +; Operator name +Parallelism = Parallelism +; Operator description +ParallelismDescription = An operation involving parallelism. +; Operator name +Put = Put +; Operator description +PutDescription = Export the rows from a local or external table to an external table. +; Operator name +DistributeStreams = Distribute Streams +; Operator description +DistributeStreamsDescription = Distribute streams. +; Operator name +GatherStreams = Gather Streams +; Operator description +GatherStreamsDescription = Gather streams. +; Operator name +RepartitionStreams = Repartition Streams +; Operator description +RepartitionStreamsDescription = Repartition streams. +; Operator name +EagerSpool = Eager Spool +; Operator description +EagerSpoolDescription = Eager Spool. +; Operator name +LazySpool = Lazy Spool +; Operator description +LazySpoolDescription = Lazy Spool. +; Operator name +Filter = Filter +; Operator description +FilterDescription = Restricting the set of rows based on a predicate. +; Operator name +Assert = Assert +; Operator description +AssertDescription = Used to verify that a specified condition exists. +; Operator name +HashMatch = Hash Match +; Operator description +HashMatchDescription = Use each row from the top input to build a hash table, and each row from the bottom input to probe into the hash table, outputting all matching rows. +; Operator name +HashMatchTeam = Hash Match Team +; Operator description +HashMatchTeamDescription = A contributor among multiple cooperating hashing operations. +; Operator name +HashMatchRoot = Hash Match Root +; Operator description +HashMatchRootDescription = The root member of a team of connected hash operators sharing a common hash function and partitioning strategy. +; Operator name +BookmarkLookup = Bookmark Lookup +; Operator description +BookmarkLookupDescription = Use a Bookmark (RID or clustering key) to look up the corresponding row in the table or clustered index. +; Operator name +LogRowScan = Log Row Scan +; Operator description +LogRowScanDescription = Scan the rows in the log. +; Operator name +MergeJoin = Merge Join +; Operator description +MergeJoinDescription = Match rows from two suitably sorted input tables exploiting their sort order. +; Operator name +NestedLoops = Nested Loops +; Operator description +NestedLoopsDescription = For each row in the top (outer) input, scan the bottom (inner) input, and output matching rows. +; Operator name +Print = Print +; Operator description +PrintDescription = Print. +; Operator name +ComputeScalar = Compute Scalar +; Operator description +ComputeScalarDescription = Compute new values from existing values in a row. +; Operator name +MergeInterval = Merge Interval +; Operator description +MergeIntervalDescription = Merge interval. +; Operator name +Rank = Rank +; Operator description +RankDescription = Creates a computed column with the rank of the values in an existing column in the table. +; Operator name +RowCountSpool = Row Count Spool +; Operator description +RowCountSpoolDescription = Stores the data from the input into a temporary table in order to optimize rewinds. +; Operator name +Segment = Segment +; Operator description +SegmentDescription = Segment. +; Operator name +Sequence = Sequence +; Operator description +SequenceDescription = Process each input, in sequence from top to bottom. +; Operator name +SequenceProject = Sequence Project +; Operator description +SequenceProjectDescription = Adds columns to perform computations over an ordered set. +; Operator name +Split = Split +; Operator description +SplitDescription = Split. +; Operator name +StreamAggregate = Stream Aggregate +; Operator description +StreamAggregateDescription = Compute summary values for groups of rows in a suitably sorted stream. +; Operator name +TableScan = Table Scan +; Operator description +TableScanDescription = Scan rows from a table. +; Operator name +ClusteredIndexScan = Clustered Index Scan +; Operator description +ClusteredIndexScanDescription = Scanning a clustered index, entirely or only a range. +; Operator name +ClusteredIndexSeek = Clustered Index Seek +; Operator description +ClusteredIndexSeekDescription = Scanning a particular range of rows from a clustered index. +; Operator name +DeletedScan = Deleted Scan +; Operator description +DeletedScanDescription = Scanning the pseudo-table 'deleted' within a trigger. +; Operator name +InsertedScan = Inserted Scan +; Operator description +InsertedScanDescription = Scan the pseudo-table 'inserted' within a trigger. +; Operator name +ParameterTableScan = Parameter Table Scan +; Operator description +ParameterTableScanDescription = Scan an internal table of parameter values. +; Operator name +IndexScan = Index Scan +; Operator description +IndexScanDescription = Scan a nonclustered index, entirely or only a range. +; Operator name +IndexSeek = Index Seek +; Operator description +IndexSeekDescription = Scan a particular range of rows from a nonclustered index. +; Operator name +ColumnstoreIndexScan = Columnstore Index Scan +; Operator description +ColumnstoreIndexScanDescription = Scan a columnstore index, entirely or only a range. +; Operator name +ColumnstoreIndexUpdate = Columnstore Index Update +; Operator description +ColumnstoreIndexUpdateDescription = Update rows in a columnstore index. +; Operator name +ColumnstoreIndexInsert = Columnstore Index Insert +; Operator description +ColumnstoreIndexInsertDescription = Insert rows in a columnstore index. +; Operator name +ColumnstoreIndexMerge = Columnstore Index Merge +; Operator description +ColumnstoreIndexMergeDescription = Merge rows in a columnstore index. +; Operator name +ColumnstoreIndexDelete = Columnstore Index Delete +; Operator description +ColumnstoreIndexDeleteDescription = Delete rows from a columnstore index. +; Operator name +RemoteScan = Remote Scan +; Operator description +RemoteScanDescription = Scan rows in a table stored in a database or file other than the current database server. +; Operator name +RemoteIndexScan = Remote Index Scan +; Operator description +RemoteIndexScanDescription = Scan an index stored in a database or file other than the current database server. +; Operator name +RemoteIndexSeek = Remote Index Seek +; Operator description +RemoteIndexSeekDescription = Scan a particular range of rows from a clustered index that is stored in a database or file other than the current database server. +; Operator name +RemoteQuery = Remote Query +; Operator description +RemoteQueryDescription = Send a SQL query to another than the current SQL Server. +; Operator name +RemoteInsert = Remote Insert +; Operator description +RemoteInsertDescription = Insert rows into a table stored in a database or file other than the current database server. +; Operator name +RemoteUpdate = Remote Update +; Operator description +RemoteUpdateDescription = Update rows in a table stored in a database or file other than the current database server. +; Operator name +RemoteDelete = Remote Delete +; Operator description +RemoteDeleteDescription = Delete rows in a table stored in a database or file other than the current database server. +; Operator name +ClusteredUpdate = Clustered Update +; Operator description +ClusteredUpdateDescription = Clustered Update. +; Operator name +Sort = Sort +; Operator description +SortDescription = Sort the input. +; Operator name +TableSpool = Table Spool +; Operator description +TableSpoolDescription = Stores the data from the input into a temporary table in order to optimize rewinds. +; Operator name +IndexSpool = Index Spool +; Operator description +IndexSpoolDescription = Reformats the data from the input into a temporary index, which is then used for seeking with the supplied seek predicate. +; Operator name +TableUpdate = Table Update +; Operator description +TableUpdateDescription = Update input rows in the table specified in the Argument field. +; Operator name +TableInsert = Table Insert +; Operator description +TableInsertDescription = Insert input rows into the table specified in Argument field. +; Operator name +TableDelete = Table Delete +; Operator description +TableDeleteDescription = Delete input rows from the table specified in Argument field. +; Operator name +TableMerge = Table Merge +; Operator description +TableMergeDescription = Merge input rows in the table specified in Argument field. +; Operator name +IndexUpdate = Index Update +; Operator description +IndexUpdateDescription = Update rows in an index. +; Operator name +IndexInsert = Index Insert +; Operator description +IndexInsertDescription = Insert rows into an index. +; Operator name +IndexDelete = Index Delete +; Operator description +IndexDeleteDescription = Delete rows from index. +; Operator name +ClusteredIndexUpdate = Clustered Index Update +; Operator description +ClusteredIndexUpdateDescription = Update rows in a clustered index. +; Operator name +ClusteredIndexInsert = Clustered Index Insert +; Operator description +ClusteredIndexInsertDescription = Insert rows in a clustered index. +; Operator name +ClusteredIndexMerge = Clustered Index Merge +; Operator description +ClusteredIndexMergeDescription = Merge rows in a clustered index. +; Operator name +ClusteredIndexDelete = Clustered Index Delete +; Operator description +ClusteredIndexDeleteDescription = Delete rows from a clustered index. +; Operator name +Top = Top +; Operator description +TopDescription = Select the first few rows based on a sort order. +; Operator name +Bitmap = Bitmap +; Operator description +BitmapDescription = Bitmap. +; Operator name +UDX = UDX +; Operator description +UDXDescription = UDX. +; Show plan's Window node property +Window = Window Spool +; Show plan's Window node property description +WindowDescription = Expands each row into the set of rows that represent the window associated with it. +; Show plan's Window Aggregate node property +WindowAggregate = Window Aggregate +; Show plan's Window Aggregate node property description +WindowAggregateDescription = Computes values of functions across the windows defined by the OVER clause. Input rowset is suitably sorted stream. +; Operator name +BatchHashTableBuild = Batch Hash Table Build +; Operator description +BatchHashTableBuildDescription = Batch Hash Table Build. +; Operator name +Switch = Switch +; Operator description +SwitchDescription = Switch. +; Operator name +TFP = Predict +; Operator description +TFPDescription = Applies a trained machine learning model to input data +; Operator name +TableValueFunction = Table Valued Function +; Operator description +TableValueFunctionDescription = Table valued function. +; Operator name +Aggregate = Aggregate +; Operator description +AggregateDescription = Calculates an expression containing SUM, COUNT, MIN, MAX, or AVG. +; Operator name +ArithmeticExpression = Arithmetic Expression +; Operator description +ArithmeticExpressionDescription = Computes a new value from existing values in a row. +; Operator name +Delete = Delete +; Operator description +DeleteDescription = Removes the specified rows from the specified table. +; Operator name +Insert = Insert +; Operator description +InsertDescription = Adds a row to table. +; Operator name +Locate = Locate +; Operator description +LocateDescription = Fetching a full row from a heap or a clustered index. +; Operator name +Spool = Spool +; Operator description +SpoolDescription = Saving temporarily an intermediate query result. +; Operator name +SQL = SQL +; Operator description +SQLDescription = SQL. +; Operator name +Update = Update +; Operator description +UpdateDescription = Modify the values in the specified table. +; Operator name +Assign = Assign +; Operator description +AssignDescription = Validate referential integrity constraints. +; Operator name +Convert = Convert +; Operator description +ConvertDescription = Implicit or explicit conversion of one scalar datatype to another. +; Operator name +Declare = Declare +; Operator description +DeclareDescription = Allocates a local variable. +; Operator name +If = If +; Operator description +IfDescription = Conditional processing based on an expression. +; Operator name +Intrinsic = Intrinsic +; Operator description +IntrinsicDescription = Invokes an internal Transact-SQL function. +; Operator name +SetFunction = Set Function +; Operator description +SetFunctionDescription = Set Function. +; Operator name +Dynamic = Dynamic +; Operator description +DynamicDescription = Cursor that can see all changes made by others. +; Operator name +FetchQuery = Fetch Query +; Operator description +FetchQueryDescription = The query used to retrieve rows when a fetch is issued against a cursor. +; Operator name +FastForward = Fast Forward +; Operator description +FastForwardDescription = Fast Forward. +; Operator name +Keyset = Keyset +; Operator description +KeysetDescription = Cursor that can see updates made by others, but not inserts. +; Operator name +PopulationQuery = Population Query +; Operator description +PopulationQueryDescription = The query used to populate a cursor's work table when the cursor is opened. +; Operator name +RefreshQuery = Refresh Query +; Operator description +RefreshQueryDescription = Fetches current data for rows in fetch buffer. +; Operator name +Snapshot = Snapshot +; Operator description +SnapshotDescription = A cursor that does not see changes made by others. +; Operator name +RIDLookup = RID Lookup +; Operator description +RIDLookupDescription = RID Lookup +; Operator name +KeyLookup = Key Lookup +; Operator description +KeyLookupDescription = Uses a supplied clustering key to lookup on a table that has a clustered index. +; Operator name +LogicalKeyLookup = Key Lookup +; Operator name +AdaptiveJoin = Adaptive Join +; Operator description +AdaptiveJoinDescription = Chooses dynamically between hash join and nested loops. +; Operator name +ForeignKeyReferencesCheck = Foreign Key References Check +; Operator description +ForeignKeyReferencesCheckDescription = Checks referential integrity of the delete operation. +# +# PDW Operators +# +; Operator name +Apply = Apply +; Operator description +ApplyDescription = Apply opration. +; Operator name +Broadcast = Broadcast +; Operator description +BroadcastDescription = Broadcast data movement. +; Operator name +ComputeToControlNode = Compute To Control Node +; Operator description +ComputeToControlNodeDescription = Data flow from compute nodes to control node. +; Operator name +ConstTableGet = Constant Table Get +; Operator description +ConstTableGetDescription = Get tuples from contant table. +; Operator name +ControlToComputeNodes = Control To Compute Nodes +; Operator description +ControlToComputeNodesDescription = Data flow from control node to compute nodes. +; Operator name +ExternalBroadcast = External Broadcast +; Operator description +ExternalBroadcastDescription = Broadcast data movement for external table. +; Operator name +ExternalExport = External Export +; Operator description +ExternalExportDescription = Export data movement for external table. +; Operator name +ExternalLocalStreaming = External Local Streaming +; Operator description +ExternalLocalStreamingDescription = Streaming data movement between external table and local table. +; Operator name +ExternalRoundRobin = External RoundRobin +; Operator description +ExternalRoundRobinDescription = RoundRobin data movement for external table. +; Operator name +ExternalShuffle = External Shuffle +; Operator description +ExternalShuffleDescription = Shuffle data movement for external table. +; Operator name +Get = Get +; Operator description +GetDescription = Get tuples from table. +; Operator name +GbApply = Group by and Apply +; Operator description +GbApplyDescription = Group by and Apply. +; Operator name +GbAgg = Group by Aggregates +; Operator description +GbAggDescription = Group by aggregates. +; Operator name +Join = Join +; Operator description +JoinDescription = Join tables. +; Operator name +LocalCube = Rollup Aggregate +; Operator description +LocalCubeDescription = This represents a ROLLUP operator or a CUBE operator. +; Operator name +Project = Project +; Operator description +ProjectDescription = Project columns. +; Operator name +Shuffle = Shuffle +; Operator description +ShuffleDescription = Shuffle data movement. +; Operator name +SingleSourceRoundRobin = Single Source RoundRobin +; Operator description +SingleSourceRoundRobinDescription = Single Source RoundRobin data movement. +; Operator name +SingleSourceShuffle = Single Source Shuffle +; Operator description +SingleSourceShuffleDescription = Single Source Shuffle data movement. +; Operator name +Trim = Trim +; Operator description +TrimDescription = Trim data. +; Operator name +Union = Union +; Operator description +UnionDescription = Union tables. +; Operator name +UnionAll = Union All +; Operator description +UnionAllDescription = Union All tables. +;Format for name / value pair - {0} is property name, {1} is property value +NameValuePair(name, value) = {0}: {1} +;Size in Bytes format +SizeInBytesFormat = {0} B +;Size in KiloBytes format +SizeInKiloBytesFormat = {0} KB +;Size in Bytes format +SizeInMegaBytesFormat = {0} MB +;Size in GigaBytes format +SizeInGigaBytesFormat = {0} GB +;Size in TeraBytes format +SizeInTeraBytesFormat = {0} TB \ No newline at end of file diff --git a/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.xlf b/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.xlf index 00e755db..a5644bdf 100644 --- a/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.xlf +++ b/src/Microsoft.SqlTools.ServiceLayer/Localization/sr.xlf @@ -2178,6 +2178,3407 @@ Adding SQL bindings is not supported for .NET 5 + + Statement + Statement + Statement + + + In most cases, contains the text of the Transact-SQL statement. For rows of type PLAN_ROW, contains a description of the operation. + In most cases, contains the text of the Transact-SQL statement. For rows of type PLAN_ROW, contains a description of the operation. + Statement description + + + Physical Operation + Physical Operation + Physical Operation + + + Physical implementation algorithm for the node. For rows of type PLAN_ROWS only. + Physical implementation algorithm for the node. For rows of type PLAN_ROWS only. + Physical Operation description + + + Logical Operation + Logical Operation + Logical Operation + + + Relational algebraic operator this node represents. For rows of type PLAN_ROWS only. + Relational algebraic operator this node represents. For rows of type PLAN_ROWS only. + Logical Operation description + + + Description + Description + Operation description. Short + + + Operation description. + Operation description. + Operation description + + + Argument + Argument + Operation Argument. Short + + + Provides supplemental information about the operation being performed. The contents of this column depend on the physical operator. + Provides supplemental information about the operation being performed. The contents of this column depend on the physical operator. + Operation Argument description + + + Object + Object + Object field + + + Object. + Object. + Object field description + + + Index Kind + Index Kind + IndexKind field + + + Type of index for the referenced object. + Type of index for the referenced object. + IndexKind field description + + + Defined Values + Defined Values + Defined Values + + + Contains a comma-separated list of values introduced by this operator, which may be computed expressions present in the current query, or internal values introduced by the query processor in order to process this query. For rows of type PLAN_ROWS only. + Contains a comma-separated list of values introduced by this operator, which may be computed expressions present in the current query, or internal values introduced by the query processor in order to process this query. For rows of type PLAN_ROWS only. + Defined Values description + + + Output List + Output List + Output List + + + Contains a comma-separated list of columns being projected by the current operation. + Contains a comma-separated list of columns being projected by the current operation. + Output List + + + Warnings + Warnings + Warnings + + + Contains a comma-separated list of warning messages relating to the current operation. Warning messages may include the string 'NO STATS:()' with a list of columns. + Contains a comma-separated list of warning messages relating to the current operation. Warning messages may include the string 'NO STATS:()' with a list of columns. + Warnings description + + + Parallel + Parallel + Parallel + + + Whether the operator is running in parallel. + Whether the operator is running in parallel. + Parallel description + + + Estimated Number of Rows Per Execution + Estimated Number of Rows Per Execution + Estimated Number of Rows Per Execution + + + Estimated number of rows per execution output by this operator. This is for PLAN_ROWS only. + Estimated number of rows per execution output by this operator. This is for PLAN_ROWS only. + Estimated Number of Rows Per Execution description + + + Estimated Number of Rows for All Executions + Estimated Number of Rows for All Executions + Estimated Number of Rows for All Executions + + + Estimated number of rows for all executions output by this operator. This is for PLAN_ROWS only. + Estimated number of rows for all executions output by this operator. This is for PLAN_ROWS only. + Estimated Number of Rows for All Executions description + + + Estimated Number of Rows to be Read + Estimated Number of Rows to be Read + Estimated Rows Read + + + Number of rows estimated to be read by this operator. This value may differ from "Estimated Number of Rows for All Executions" if the operator has a predicate. + Number of rows estimated to be read by this operator. This value may differ from "Estimated Number of Rows for All Executions" if the operator has a predicate. + Estimated Rows Read description + + + Is GraphDB Transitive Closure + Is GraphDB Transitive Closure + GraphDB Transitive Closure + + + Whether the sequence represents a GraphDB transitive closure. + Whether the sequence represents a GraphDB transitive closure. + GraphDB Transitive Closure Description + + + IsInterleavedExecuted + IsInterleavedExecuted + Interleaved Executed + + + Whether the operator is interleaved executed. + Whether the operator is interleaved executed. + Interleaved Executed Description + + + Is Adaptive + Is Adaptive + Is Adaptive + + + Whether the operator is adaptive. + Whether the operator is adaptive. + Is Adaptive description + + + Adaptive Threshold Rows + Adaptive Threshold Rows + Adaptive Threshold Rows + + + If this is an adaptive operator, the cardinality at which it adapts. + If this is an adaptive operator, the cardinality at which it adapts. + Adaptive Threshold Rows description + + + Estimated Join Type + Estimated Join Type + Estimated Join Type + + + The join type (nested loops or hash join) estimated by the query optimizer before adapting. + The join type (nested loops or hash join) estimated by the query optimizer before adapting. + Estimated Join Type description + + + Actual Join Type + Actual Join Type + Actual Join Type + + + The actual join picked (nested loops or hash join) as part of adaptive join execution. + The actual join picked (nested loops or hash join) as part of adaptive join execution. + Actual Join Type Description + + + Estimated Row Size + Estimated Row Size + Estimated Row Size + + + Estimated average row size of the row being passed through this operator. + Estimated average row size of the row being passed through this operator. + Estimated Row Size description + + + Estimated I/O Cost + Estimated I/O Cost + Estimated IO Cost + + + Estimated I/O cost for this operator. For rows of type PLAN_ROWS only. + Estimated I/O cost for this operator. For rows of type PLAN_ROWS only. + Estimated IO Cost description + + + Estimated CPU Cost + Estimated CPU Cost + Estimated CPU Cost + + + Estimated CPU cost for this operator. For rows of type PLAN_ROWS only. + Estimated CPU cost for this operator. For rows of type PLAN_ROWS only. + Estimated CPU Cost description + + + Estimated Number of Executions + Estimated Number of Executions + Estimated Number of Executions + + + Estimated number of times this operator will be executed while running the current query. + Estimated number of times this operator will be executed while running the current query. + Estimated Number of Executions description + + + Estimated Operator Cost + Estimated Operator Cost + Show plan node property name + + + Estimated cost of this operator. + Estimated cost of this operator. + Estimated Costs description + + + Estimated Subtree Cost + Estimated Subtree Cost + Estimated Subtree Cost + + + Estimated cumulative cost of this operation and all child operations. + Estimated cumulative cost of this operation and all child operations. + Estimated Subtree Cost description + + + Actual Number of Rows for All Executions + Actual Number of Rows for All Executions + Number of Rows + + + Actual number of rows for All Executions output by this operator. For rows of type PLAN_ROWS only. + Actual number of rows for All Executions output by this operator. For rows of type PLAN_ROWS only. + Number of Rows description + + + Number of Rows Read + Number of Rows Read + Number of Rows Read by a Rowset (Table or Index) + + + Number of rows read from a table or an index prior to applying a predicate filter. For rows of type PLAN_ROWS only. + Number of rows read from a table or an index prior to applying a predicate filter. For rows of type PLAN_ROWS only. + Number of Rows Read by a Rowset (Table or Index) Description + + + Actual Number of Batches + Actual Number of Batches + Number of Batches + + + Actual number of Batches output by this operator. + Actual number of Batches output by this operator. + Number of Batches description + + + Number of Executions + Number of Executions + Number of Executions + + + Number of times this operator will be executed while running the current query. + Number of times this operator will be executed while running the current query. + Number of Executions description + + + Estimated Data Size + Estimated Data Size + Estimated Data Size + + + Estimated data size of the data being passed through this operator. + Estimated data size of the data being passed through this operator. + Estimated Data Size description + + + Parameter List + Parameter List + Show plan's simple root node property + + + Parameter list. + Parameter list. + Show plan's simple root node property description + + + Memory Fractions + Memory Fractions + Show plan's simple root node property + + + Memory fractions. + Memory fractions. + Show plan's simple root node property description + + + Memory Fractions Input + Memory Fractions Input + Show plan's simple root node property + + + Memory fractions input. + Memory fractions input. + Show plan's simple root node property description + + + Memory Fractions Output + Memory Fractions Output + Show plan's simple root node property + + + Memory fractions output. + Memory fractions output. + Show plan's simple root node property description + + + Name + Name + Show plan's UDX node property + + + Name. + Name. + Show plan's UDX node property description + + + Values + Values + Show plan's ConstantScan node property + + + Values. + Values. + Show plan's ConstantScan node property description + + + Cached plan size + Cached plan size + CachedPlanSize property + + + Cached plan size. + Cached plan size. + Description for CachedPlanSize property + + + Use plan + Use plan + UsePlan property + + + Contains Inline Scalar Tsql Udfs + Contains Inline Scalar Tsql Udfs + InlineScalarTsqlUdf property + + + Degree of Parallelism + Degree of Parallelism + DegreeOfParallelism property + + + Degree of parallelism. + Degree of parallelism. + Description for DegreeOfParallelism property + + + Effective Degree of Parallelism + Effective Degree of Parallelism + EffectiveDegreeOfParallelism property + + + Max degree of parallelism during columnstore index build. + Max degree of parallelism during columnstore index build. + Description for EffectiveDegreeOfParallelism property + + + Memory Grant + Memory Grant + Root node for show plan property + + + Memory grant. + Memory grant. + Description for MemoryGrant property + + + Remote Destination + Remote Destination + Show plan node property + + + Remote object. + Remote object. + Show plan node property description + + + Remote Object + Remote Object + Show plan node property + + + Remote object. + Remote object. + Show plan node property description + + + Remote Source + Remote Source + Show plan node property + + + Remote source. + Remote source. + Show plan node property description + + + Used UDX Columns + Used UDX Columns + Show plan node property + + + Used UDX columns. + Used UDX columns. + Show plan node property description + + + Inner Side Join columns + Inner Side Join columns + Show plan node property + + + Inner side join columns. + Inner side join columns. + Show plan node property description + + + Outer Side Join columns + Outer Side Join columns + Show plan node property + + + Outer side join columns. + Outer side join columns. + Show plan node property description + + + Where (join columns) + Where (join columns) + Show plan node property + + + Residual + Residual + Show plan node property + + + Residual. + Residual. + Show plan node property description + + + Pass Through + Pass Through + Show plan node property + + + Pass throuh. + Pass throuh. + Show plan node property description + + + Many to Many + Many to Many + Show plan node property + + + Many to many. + Many to many. + Show plan node property description + + + Partition Columns + Partition Columns + Show plan node property + + + Partition columns. + Partition columns. + Show plan node property description + + + Ascending + Ascending + Column sort type + + + Descending + Descending + Column sort type + + + Hash Keys + Hash Keys + Show plan node property + + + Hash keys. + Hash keys. + Show plan node property description + + + Probe Column + Probe Column + Show plan node property + + + Probe column. + Probe column. + Show plan node property description + + + Partitioning Type + Partitioning Type + Show plan node property + + + Partitioning type. + Partitioning type. + Show plan node property description + + + Group By + Group By + Show plan node property + + + Group by. + Group by. + Show plan node property description + + + Grouping Sets + Grouping Sets + Show plan node property + + + The group sets list. Each Value is a reverse bit map for the grouping columns in Group By property. + The group sets list. Each Value is a reverse bit map for the grouping columns in Group By property. + Show plan node property description + + + Segment Column + Segment Column + Show plan node property + + + Segment column. + Segment column. + Show plan node property description + + + Rank Columns + Rank Columns + Show plan node property + + + Rank columns. + Rank columns. + Show plan node property description + + + Predicate + Predicate + Show plan node property + + + Predicate. + Predicate. + Show plan node property description + + + Outer References + Outer References + Show plan node property + + + Outer references. + Outer references. + Show plan node property description + + + Scalar Operator + Scalar Operator + Show plan node property + + + Action Column + Action Column + Show plan node property + + + Action column. + Action column. + Show plan node property description + + + Original Action Column + Original Action Column + Show plan node property + + + Original Action column. + Original Action column. + Show plan node property description + + + Top Rows + Top Rows + Show plan node property + + + Top Rows. + Top Rows. + Show plan node property description + + + Seek Predicate + Seek Predicate + Show plan node property + + + Seek predicate. + Seek predicate. + Show plan node property description + + + Partitioned + Partitioned + Show plan node property + + + Whether the operation is on a partitioned table or index. + Whether the operation is on a partitioned table or index. + Show plan node property description + + + Seek Keys + Seek Keys + Show plan node property + + + Keys used by a seek operation. + Keys used by a seek operation. + Show plan node property description + + + Actual Partitions Accessed + Actual Partitions Accessed + Show plan node property + + + Actual Partition Count + Actual Partition Count + Show plan node property + + + Tie Columns + Tie Columns + Show plan node property + + + Tie columns. + Tie columns. + Show plan node property description + + + Is Percent + Is Percent + Show plan node property + + + Is percent. + Is percent. + Show plan node property description + + + With Ties + With Ties + Show plan node property + + + With ties. + With ties. + Show plan node property description + + + Partition ID + Partition ID + Show plan node property + + + Partition ID. + Partition ID. + Show plan node property description + + + Ordered + Ordered + Show plan node property + + + Ordered. + Ordered. + Show plan node property description + + + Scan Direction + Scan Direction + ScanDirection property + + + Direction of the scan operation as either forward or backward. + Direction of the scan operation as either forward or backward. + ScanDirection property description + + + Forced Index + Forced Index + Show plan node property + + + Forced index. + Forced index. + Show plan node property description + + + Predicate + Predicate + Show plan node property + + + Predicate + Predicate + Show plan node property description + + + Top Expression + Top Expression + Show plan node property + + + Top expression. + Top expression. + Show plan node property description + + + Hash Keys Build + Hash Keys Build + Show plan node property + + + Hash keys build. + Hash keys build. + Show plan node property description + + + Hash Keys Probe + Hash Keys Probe + Show plan node property + + + Hash keys probe. + Hash keys probe. + Show plan node property description + + + Build Residual + Build Residual + Show plan node property + + + Build residual. + Build residual. + Show plan node property description + + + Probe Residual + Probe Residual + Show plan node property + + + Probe residual. + Probe residual. + Show plan node property description + + + Seek Predicates + Seek Predicates + Show plan node property + + + Seek predicates. + Seek predicates. + Show plan node property description + + + Set Options + Set Options + Set options property in show plan + + + Set options. + Set options. + Set options property in show plan description + + + Optimization Level + Optimization Level + Optimization Level property in show plan + + + Optimization level. + Optimization level. + Optimization Level property in show plan description + + + Reason For Early Termination Of Statement Optimization + Reason For Early Termination Of Statement Optimization + StatementOptmEarlyAbortReason property + + + Time Out + Time Out + StatementOptmEarlyAbortReason property value + + + Memory Limit Exceeded + Memory Limit Exceeded + StatementOptmEarlyAbortReason property value + + + Good Enough Plan Found + Good Enough Plan Found + StatementOptmEarlyAbortReason property value + + + Estimated Rebinds + Estimated Rebinds + Estimated Rebinds + + + Estimated rebinds. + Estimated rebinds. + Estimated Rebinds Description + + + Estimated Rewinds + Estimated Rewinds + Estimated Rewinds + + + Estimated rewinds. + Estimated rewinds. + Estimated Rewinds Description + + + Actual Number of Locally Aggregated Rows + Actual Number of Locally Aggregated Rows + Actual Locally Aggregated Rows + + + Actual number of locally aggregated rows + Actual number of locally aggregated rows + Actual Locally Aggregated Rows Description + + + Actual Rebinds + Actual Rebinds + Actual Rebinds + + + Actual Rebinds. + Actual Rebinds. + Actual Rebinds Description + + + Actual Rewinds + Actual Rewinds + Actual Rewinds + + + Actual Rewinds. + Actual Rewinds. + Actual Rewinds Description + + + Actual I/O Statistics + Actual I/O Statistics + Actual I/O Statistics + + + Actual I/O Statistics + Actual I/O Statistics + Actual I/O Statistics Description + + + Actual Time Statistics + Actual Time Statistics + Actual Time Statistics + + + Actual Time Statistics + Actual Time Statistics + Actual Time Statistics Description + + + Actual Elapsed Time (ms) + Actual Elapsed Time (ms) + Actual Elapsed Milliseconds + + + Actual elapsed time in milliseconds + Actual elapsed time in milliseconds + Actual Elapsed Milliseconds Description + + + Actual Elapsed CPU Time (ms) + Actual Elapsed CPU Time (ms) + Actual CPU Time Milliseconds + + + Actual elapsed CPU time in milliseconds + Actual elapsed CPU time in milliseconds + Actual CPU Time Milliseconds Description + + + Actual Scans + Actual Scans + Actual Scans + + + Actual Scans + Actual Scans + Actual Scans Description + + + Actual Logical Reads + Actual Logical Reads + Actual Logical Reads + + + Actual Logical Reads + Actual Logical Reads + Actual Logical Reads Description + + + Actual Physical Reads + Actual Physical Reads + Actual Physical Reads + + + Actual Physical Reads + Actual Physical Reads + Actual Physical Reads Description + + + Actual Page Server Reads + Actual Page Server Reads + Actual Page Server Reads + + + Actual Page Server Reads + Actual Page Server Reads + Actual Page Server Reads Description + + + Actual Read Aheads + Actual Read Aheads + Actual Read Aheads + + + Actual Read Aheads + Actual Read Aheads + Actual Read Aheads Description + + + Actual Page Server Read Aheads + Actual Page Server Read Aheads + Actual Page Server Read Aheads + + + Actual Page Server Read Aheads + Actual Page Server Read Aheads + Actual Page Server Read Aheads Description + + + Actual Lob Logical Reads + Actual Lob Logical Reads + Actual Lob Logical Reads + + + Actual Lob Logical Reads + Actual Lob Logical Reads + Actual Lob Logical Reads Description + + + Actual Lob Physical Reads + Actual Lob Physical Reads + Actual Lob Physical Reads + + + Actual Lob Physical Reads + Actual Lob Physical Reads + Actual Lob Physical Reads Description + + + Actual Lob Page Server Reads + Actual Lob Page Server Reads + Actual Lob Page Server Reads + + + Actual Lob Page Server Reads + Actual Lob Page Server Reads + Actual Lob Page Server Reads Description + + + Actual Lob Read Aheads + Actual Lob Read Aheads + Actual Lob Read Aheads + + + Actual Lob Read Aheads + Actual Lob Read Aheads + Actual Lob Read Aheads Description + + + Actual Lob Page Server Read Aheads + Actual Lob Page Server Read Aheads + Actual Lob Page Server Read Aheads + + + Actual Lob Page Server Read Aheads + Actual Lob Page Server Read Aheads + Actual Lob Page Server Read Aheads Description + + + Memory Usage + Memory Usage + ActualMemoryGrantStats + + + Hpc Row Count + Hpc Row Count + Hpc Row Count + + + Number of rows processed by Hpc devices. + Number of rows processed by Hpc devices. + Hpc Row Count Description + + + Hpc Kernel Elapsed Time in Us + Hpc Kernel Elapsed Time in Us + Hpc Kernel Elapsed Us + + + Elapsed time (in micro seconds) of Hpc device kernel execution. + Elapsed time (in micro seconds) of Hpc device kernel execution. + Hpc Kernel Elapsed Us Description + + + Hpc Host To Device Bytes + Hpc Host To Device Bytes + Hpc Host To Device Bytes + + + Data transferred from host to Hpc device in bytes. + Data transferred from host to Hpc device in bytes. + Hpc Host To Device Bytes Description + + + Hpc Device To Host Bytes + Hpc Device To Host Bytes + Hpc Device To Host Bytes + + + Data transferred from Hpc device to host in bytes. + Data transferred from Hpc device to host in bytes. + Hpc Device To Host Bytes Description + + + Input Memory + Input Memory + InputMemoryGrant + + + Output Memory + Output Memory + OutputMemoryGrant + + + Used Memory + Used Memory + UsedMemoryGrant + + + Distinct + Distinct + Distinct + + + Distinct. + Distinct. + Distinct description + + + Order By + Order By + OrderBy + + + Order by. + Order by. + OrderBy description + + + Operator used tempdb to spill data during execution + Operator used tempdb to spill data during execution + + + + Columns With No Statistics + Columns With No Statistics + ColumnsWithNoStatistics property + + + Columns with no statistics warning. + Columns with no statistics warning. + ColumnsWithNoStatistics property description + + + No Join Predicate + No Join Predicate + NoJoinPredicate property + + + No Join predicate warning. + No Join predicate warning. + NoJoinPredicate property description + + + Operator used tempdb to spill data during execution with spill level {0} + Operator used tempdb to spill data during execution with spill level {0} + SpillToTempDbOld property + + + Operator used tempdb to spill data during execution with spill level {0} and {1} spilled thread(s) + Operator used tempdb to spill data during execution with spill level {0} and {1} spilled thread(s) + SpillToTempDb property + + + Spill to tempdb warning. + Spill to tempdb warning. + SpillToTempDb property description + + + Sort wrote {0} pages to and read {1} pages from tempdb with granted memory {2}KB and used memory {3}KB + Sort wrote {0} pages to and read {1} pages from tempdb with granted memory {2}KB and used memory {3}KB + SortSpillDetails property + + + Details of sort spill + Details of sort spill + SortSpillDetails property description + + + Hash wrote {0} pages to and read {1} pages from tempdb with granted memory {2}KB and used memory {3}KB + Hash wrote {0} pages to and read {1} pages from tempdb with granted memory {2}KB and used memory {3}KB + HashSpillDetails property + + + Details of hash spill + Details of hash spill + HahSpillDetails property description + + + A partial update was converted to a full update because of an online index build + A partial update was converted to a full update because of an online index build + FullUpdateForOnlineIndexBuild property + + + Full update for online index build warning + Full update for online index build warning + FullUpdateForOnlineIndexBuild property description + + + The query had to wait {0} seconds for {1} during execution + The query had to wait {0} seconds for {1} during execution + Wait property + + + Query wait warning. + Query wait warning. + Wait property description + + + Type conversion in expression ({0}) may affect "{1}" in query plan choice + Type conversion in expression ({0}) may affect "{1}" in query plan choice + PlanAffectingConvert property + + + Plan-affecting type conversion warning. + Plan-affecting type conversion warning. + PlanAffectingConvert property description + + + The query memory grant detected "{0}", which may impact the reliability. Grant size: Initial {1} KB, Final {2} KB, Used {3} KB. + The query memory grant detected "{0}", which may impact the reliability. Grant size: Initial {1} KB, Final {2} KB, Used {3} KB. + MemoryGrantWarning property + + + Details on memory grant warning + Details on memory grant warning + MemoryGrantWarning property description + + + Startup Expression + Startup Expression + StartupExpression property + + + Whether a filter startup expression is used. + Whether a filter startup expression is used. + StartupExpression property description + + + Startup Expression Predicate + Startup Expression Predicate + StartupExpressionPredicate property + + + Query + Query + Query property + + + With Stack + With Stack + Stack property + + + Is Row Count + Is Row Count + RowCount property + + + Optimized + Optimized + Optimized property + + + With Prefetch + With Prefetch + WithPrefetch property + + + Prefix + Prefix + Prefix property + + + Start + Start + StartRange property + + + Start of the range. + Start of the range. + StartRange property description + + + End + End + EndRange property + + + End of the range. + End of the range. + EndRange property description + + + Range Columns + Range Columns + RangeColumns property + + + Range Expressions + Range Expressions + RangeExpressions property + + + Scan Type + Scan Type + ScanType property + + + Column Reference + Column Reference + ColumnReference property + + + Server + Server + Server property + + + Server name for the referenced object. + Server name for the referenced object. + Server property description + + + Database + Database + Database property + + + Database name for the referenced object. + Database name for the referenced object. + Database property description + + + Index + Index + Index property + + + Index name for the referenced object. + Index name for the referenced object. + Index property description + + + Schema + Schema + Schema property + + + Schema name for the referenced object. + Schema name for the referenced object. + Schema property description + + + Table + Table + Table property + + + Table name for the referenced object. + Table name for the referenced object. + Table property description + + + Alias + Alias + Alias property + + + Alias used for the referenced object. + Alias used for the referenced object. + Alias property description + + + Column + Column + Column property + + + Column name for the referenced object. + Column name for the referenced object. + Column property description + + + Computed Column + Computed Column + ComputedColumn property + + + Whether this is a computed column. + Whether this is a computed column. + ComputedColumn property description + + + Parameter Data Type + Parameter Data Type + ParameterDataType property + + + Parameter Compiled Value + Parameter Compiled Value + ParameterCompiledValue property + + + Parameter Runtime Value + Parameter Runtime Value + ParameterRuntimeValue property + + + Cursor Plan + Cursor Plan + CursorPlan property + + + Cursor Operation + Cursor Operation + CursorOperation property + + + Cursor Name + Cursor Name + CursorName property + + + Cursor Actual Type + Cursor Actual Type + CursorActualType property + + + Cursor Requested Type + Cursor Requested Type + CursorRequestedType property + + + Cursor Concurrency + Cursor Concurrency + CursorConcurrency property + + + Forward Only + Forward Only + ForwardOnly property + + + Query Plan + Query Plan + QueryPlan property + + + Operation Type + Operation Type + OperationType property + + + Node ID + Node ID + Node ID property + + + Primary Node ID + Primary Node ID + Primary Node ID property + + + Internal Debugging Information + Internal Debugging Information + Internal Info property + + + Foreign Key References Count + Foreign Key References Count + Foreign Key References Count property + + + No Matching Indexes Count + No Matching Indexes Count + No Matching Index Count property + + + Partial Matching Indexes Count + Partial Matching Indexes Count + Partial Matching Index Count property + + + Collapse + Collapse + Logical operator + + + Concatenation + Concatenation + Logical operator + + + Constant Scan + Constant Scan + Logical operator + + + Gather Streams + Gather Streams + Logical operator + + + Repartition Streams + Repartition Streams + Logical operator + + + Distribute Streams + Distribute Streams + Logical operator + + + Filter + Filter + Logical operator + + + Assert + Assert + Logical operator + + + Log Row Scan + Log Row Scan + Logical operator + + + Print + Print + Logical operator + + + Compute Scalar + Compute Scalar + Logical operator + + + Merge Interval + Merge Interval + Logical operator + + + Rank + Rank + Logical operator + + + Segment + Segment + Logical operator + + + Sequence + Sequence + Logical operator + + + Split + Split + Logical operator + + + Aggregate + Aggregate + Logical operator + + + Table Scan + Table Scan + Logical operator + + + Clustered Index Scan + Clustered Index Scan + Logical operator + + + Clustered Index Seek + Clustered Index Seek + Logical operator + + + Deleted Scan + Deleted Scan + Logical operator + + + Inserted Scan + Inserted Scan + Logical operator + + + Parameter Table Scan + Parameter Table Scan + Logical operator + + + Put + Put + Logical operator + + + Index Scan + Index Scan + Logical operator + + + Index Seek + Index Seek + Logical operator + + + Remote Scan + Remote Scan + Logical operator + + + Remote Index Scan + Remote Index Scan + Logical operator + + + Remote Index Seek + Remote Index Seek + Logical operator + + + Remote Query + Remote Query + Logical operator + + + Remote Insert + Remote Insert + Logical operator + + + Remote Update + Remote Update + Logical operator + + + Remote Delete + Remote Delete + Logical operator + + + Clustered Update + Clustered Update + Logical operator + + + Distinct Sort + Distinct Sort + Logical operator + + + Sort + Sort + Logical operator + + + Top N Sort + Top N Sort + Logical operator + + + Eager Spool + Eager Spool + Logical operator + + + Lazy Spool + Lazy Spool + Logical operator + + + Update + Update + Logical operator + + + Insert + Insert + Logical operator + + + Delete + Delete + Logical operator + + + Merge + Merge + Logical operator + + + Top + Top + Logical operator + + + Distinct + Distinct + Logical operator + + + Flow Distinct + Flow Distinct + Logical operator + + + Partial Aggregate + Partial Aggregate + Logical operator + + + Inner Apply + Inner Apply + Logical operator + + + Inner Join + Inner Join + Logical operator + + + Left Anti Semi Apply + Left Anti Semi Apply + Logical operator + + + Left Semi Apply + Left Semi Apply + Logical operator + + + Left Outer Apply + Left Outer Apply + Logical operator + + + Left Outer Join + Left Outer Join + Logical operator + + + Right Outer Join + Right Outer Join + Logical operator + + + Full Outer Join + Full Outer Join + Logical operator + + + Left Semi Join + Left Semi Join + Logical operator + + + Left Anti Semi Join + Left Anti Semi Join + Logical operator + + + Right Semi Join + Right Semi Join + Logical operator + + + Right Anti Semi Join + Right Anti Semi Join + Logical operator + + + Intersect + Intersect + Logical operator + + + Intersect All + Intersect All + Logical operator + + + Union + Union + Logical operator + + + Left Diff + Left Diff + Logical operator + + + Left Diff All + Left Diff All + Logical operator + + + Right Diff + Right Diff + Logical operator + + + Right Diff All + Right Diff All + Logical operator + + + Anti Diff + Anti Diff + Logical operator + + + Cross Join + Cross Join + Logical operator + + + Bitmap Create + Bitmap Create + Logical operator + + + UDX + UDX + Logical operator + + + Window Spool + Window Spool + Logical operator + + + Switch + Switch + Logical operator + + + Merge Stats + Merge Stats + Logical operator + + + Local Stats + Local Stats + Logical operator + + + Table Valued Function + Table Valued Function + Logical operator + + + Batch Hash Table Build + Batch Hash Table Build + Logical operator + + + Foreign Key References Check + Foreign Key References Check + Logical operator + + + RID Lookup + RID Lookup + RIDLookup operator + + + Stored Procedure + Stored Procedure + StoredProc node + + + UDF + UDF + UDF node + + + Procedure Name + Procedure Name + ProcName property + + + Storage + Storage + Storage property + + + Storage + Storage + Storage property + + + Actual Execution Mode + Actual Execution Mode + ActualExectionMode property + + + Actual Execution Mode + Actual Execution Mode + + + + Estimated Execution Mode + Estimated Execution Mode + EstimatedExecutionMode property + + + Estimated Execution Mode + Estimated Execution Mode + + + + Cost: {0} % + Cost: {0} % + "Cost: {0} percent" String to format. + Parameters: 0 - x (int) + + + Remote Data Access + Remote Data Access + Remote Data Access + + + Whether the operator uses remote procedure call (RPC) to access remote data. + Whether the operator uses remote procedure call (RPC) to access remote data. + + + + Clone Access Scope + Clone Access Scope + Clone Access Scope + + + Clones that the operator may access. + Clones that the operator may access. + + + + Primary Clones + Primary Clones + + + + Secondary Clones + Secondary Clones + + + + All Clones + All Clones + + + + Primary Or Secondary Clones + Primary Or Secondary Clones + + + + Single Clone Match + Single Clone Match + + + + Remoting + Remoting + Remoting for remote exchange operator + + + Whether the operator can run remotely. + Whether the operator can run remotely. + + + + Activation + Activation + Activation + + + Brick Routing + Brick Routing + Brick Routing + + + Fragment Id Column + Fragment Id Column + + + + Edit Query Text from Showplan XML (possibly truncated) + Edit Query Text from Showplan XML (possibly truncated) + Showplan edit query text button + + + Execution plan source type can not be recognized. + Execution plan source type can not be recognized. + error message when the ShowPlan source cannot be recognized + + + Sql Plan files (*.SqlPlan)|*.SqlPlan|All files (*.*)|*.* + Sql Plan files (*.SqlPlan)|*.SqlPlan|All files (*.*)|*.* + Save plan dialog filter string + + + Plan data is not available in XML format. Only plans from SQL Server Yukon can be saved. + Plan data is not available in XML format. Only plans from SQL Server Yukon can be saved. + Message box if user tries to save in XML show plan from Shiloh or Sphinx + + + Per-thread counter information. + Per-thread counter information. + Description of a per thread counter + + + Thread {0} + Thread {0} + Runtime counter property name. + Parameters: 0 - index (int) + + + Thread {0} on Instance {1} + Thread {0} on Instance {1} + Runtime counter property name. Thread on Instance.. + Parameters: 0 - thread (int), 1 - instance (int) + + + All threads + All threads + Runtime counter property name + + + View connection properties + View connection properties + label for Connection Properties hyperlink + + + Unknown assign type. + Unknown assign type. + Error when displaying show plan properties + + + SQL Server + SQL Server + exception message box caption + + + Zoom level must be an integer value between {0} and {1}. + Zoom level must be an integer value between {0} and {1}. + Message shown when user enters wrong zoom level. + Parameters: 0 - minimum (int), 1 - maximum (int) + + + Unknown node type. + Unknown node type. + Exception thrown when node type is unknown + + + Unknown cursor plan operation '{0}'. + Unknown cursor plan operation '{0}'. + Exception thrown by show plan when it gets unknown type of cursor plan operation. + Parameters: 0 - name (string) + + + Statement type is not recognized. + Statement type is not recognized. + Exception thrown by show plan when it gets unknown statement type + + + Rollup Information + Rollup Information + Show plan node property + + + Rollup information. + Rollup information. + Show plan node property description + + + Highest Level + Highest Level + Show plan node property + + + The highest level of grouping attributes computed in this rollup. + The highest level of grouping attributes computed in this rollup. + Show plan node property description + + + Rollup Levels + Rollup Levels + Show plan node property + + + All levels of grouping attributes computed in this rollup. + All levels of grouping attributes computed in this rollup. + Show plan node property description + + + Level + Level + Show plan node property + + + A level of grouping attributes computed in this rollup. + A level of grouping attributes computed in this rollup. + Show plan node property description + + + Remote Query + Remote Query + Operator name + + + Send a SQL query to another than the current SQL Server. + Send a SQL query to another than the current SQL Server. + Operator description + + + Compute Scalar + Compute Scalar + Operator name + + + Merge Interval + Merge Interval + Operator name + + + Print + Print + Operator name + + + Segment + Segment + Operator name + + + Split + Split + Operator name + + + Batch Hash Table Build + Batch Hash Table Build + Operator name + + + Bitmap + Bitmap + Operator name + + + Collapse + Collapse + Operator name + + + Table Spool + Table Spool + Operator name + + + Repartition Streams + Repartition Streams + Operator name + + + Assert + Assert + Operator name + + + Sort + Sort + Operator name + + + Top + Top + Operator name + + + Sequence Project + Sequence Project + Operator name + + + Spool + Spool + Operator name + + + Window Spool + Window Spool + Show plan's Window node property + + + Parallelism + Parallelism + Operator name + + + Row Count Spool + Row Count Spool + Operator name + + + Unknown + Unknown + Unkown (reused string, unkown operator, or unkown reason, or unknown ...) + + + Unknown operator. + Unknown operator. + Operator description + + + Result + Result + Operator name + + + Result. + Result. + Operator description + + + Groups an insert and delete on the same value into an update within wide update plans. + Groups an insert and delete on the same value into an update within wide update plans. + Operator description + + + Concatenation + Concatenation + Operator name + + + Append multiple input tables to form the output table. + Append multiple input tables to form the output table. + Operator description + + + Constant Scan + Constant Scan + Operator name + + + Scan an internal table of constants. + Scan an internal table of constants. + Operator description + + + An operation involving parallelism. + An operation involving parallelism. + Operator description + + + Put + Put + Operator name + + + Export the rows from a local or external table to an external table. + Export the rows from a local or external table to an external table. + Operator description + + + Distribute Streams + Distribute Streams + Operator name + + + Distribute streams. + Distribute streams. + Operator description + + + Gather Streams + Gather Streams + Operator name + + + Gather streams. + Gather streams. + Operator description + + + Repartition streams. + Repartition streams. + Operator description + + + Eager Spool + Eager Spool + Operator name + + + Eager Spool. + Eager Spool. + Operator description + + + Lazy Spool + Lazy Spool + Operator name + + + Lazy Spool. + Lazy Spool. + Operator description + + + Filter + Filter + Operator name + + + Restricting the set of rows based on a predicate. + Restricting the set of rows based on a predicate. + Operator description + + + Used to verify that a specified condition exists. + Used to verify that a specified condition exists. + Operator description + + + Hash Match + Hash Match + Operator name + + + Use each row from the top input to build a hash table, and each row from the bottom input to probe into the hash table, outputting all matching rows. + Use each row from the top input to build a hash table, and each row from the bottom input to probe into the hash table, outputting all matching rows. + Operator description + + + Hash Match Team + Hash Match Team + Operator name + + + A contributor among multiple cooperating hashing operations. + A contributor among multiple cooperating hashing operations. + Operator description + + + Hash Match Root + Hash Match Root + Operator name + + + The root member of a team of connected hash operators sharing a common hash function and partitioning strategy. + The root member of a team of connected hash operators sharing a common hash function and partitioning strategy. + Operator description + + + Bookmark Lookup + Bookmark Lookup + Operator name + + + Use a Bookmark (RID or clustering key) to look up the corresponding row in the table or clustered index. + Use a Bookmark (RID or clustering key) to look up the corresponding row in the table or clustered index. + Operator description + + + Log Row Scan + Log Row Scan + Operator name + + + Scan the rows in the log. + Scan the rows in the log. + Operator description + + + Merge Join + Merge Join + Operator name + + + Match rows from two suitably sorted input tables exploiting their sort order. + Match rows from two suitably sorted input tables exploiting their sort order. + Operator description + + + Nested Loops + Nested Loops + Operator name + + + For each row in the top (outer) input, scan the bottom (inner) input, and output matching rows. + For each row in the top (outer) input, scan the bottom (inner) input, and output matching rows. + Operator description + + + Print. + Print. + Operator description + + + Compute new values from existing values in a row. + Compute new values from existing values in a row. + Operator description + + + Merge interval. + Merge interval. + Operator description + + + Rank + Rank + Operator name + + + Creates a computed column with the rank of the values in an existing column in the table. + Creates a computed column with the rank of the values in an existing column in the table. + Operator description + + + Stores the data from the input into a temporary table in order to optimize rewinds. + Stores the data from the input into a temporary table in order to optimize rewinds. + Operator description + + + Segment. + Segment. + Operator description + + + Sequence + Sequence + Operator name + + + Process each input, in sequence from top to bottom. + Process each input, in sequence from top to bottom. + Operator description + + + Adds columns to perform computations over an ordered set. + Adds columns to perform computations over an ordered set. + Operator description + + + Split. + Split. + Operator description + + + Stream Aggregate + Stream Aggregate + Operator name + + + Compute summary values for groups of rows in a suitably sorted stream. + Compute summary values for groups of rows in a suitably sorted stream. + Operator description + + + Table Scan + Table Scan + Operator name + + + Scan rows from a table. + Scan rows from a table. + Operator description + + + Clustered Index Scan + Clustered Index Scan + Operator name + + + Scanning a clustered index, entirely or only a range. + Scanning a clustered index, entirely or only a range. + Operator description + + + Clustered Index Seek + Clustered Index Seek + Operator name + + + Scanning a particular range of rows from a clustered index. + Scanning a particular range of rows from a clustered index. + Operator description + + + Deleted Scan + Deleted Scan + Operator name + + + Scanning the pseudo-table 'deleted' within a trigger. + Scanning the pseudo-table 'deleted' within a trigger. + Operator description + + + Inserted Scan + Inserted Scan + Operator name + + + Scan the pseudo-table 'inserted' within a trigger. + Scan the pseudo-table 'inserted' within a trigger. + Operator description + + + Parameter Table Scan + Parameter Table Scan + Operator name + + + Scan an internal table of parameter values. + Scan an internal table of parameter values. + Operator description + + + Index Scan + Index Scan + Operator name + + + Scan a nonclustered index, entirely or only a range. + Scan a nonclustered index, entirely or only a range. + Operator description + + + Index Seek + Index Seek + Operator name + + + Scan a particular range of rows from a nonclustered index. + Scan a particular range of rows from a nonclustered index. + Operator description + + + Columnstore Index Scan + Columnstore Index Scan + Operator name + + + Scan a columnstore index, entirely or only a range. + Scan a columnstore index, entirely or only a range. + Operator description + + + Columnstore Index Update + Columnstore Index Update + Operator name + + + Update rows in a columnstore index. + Update rows in a columnstore index. + Operator description + + + Columnstore Index Insert + Columnstore Index Insert + Operator name + + + Insert rows in a columnstore index. + Insert rows in a columnstore index. + Operator description + + + Columnstore Index Merge + Columnstore Index Merge + Operator name + + + Merge rows in a columnstore index. + Merge rows in a columnstore index. + Operator description + + + Columnstore Index Delete + Columnstore Index Delete + Operator name + + + Delete rows from a columnstore index. + Delete rows from a columnstore index. + Operator description + + + Remote Scan + Remote Scan + Operator name + + + Scan rows in a table stored in a database or file other than the current database server. + Scan rows in a table stored in a database or file other than the current database server. + Operator description + + + Remote Index Scan + Remote Index Scan + Operator name + + + Scan an index stored in a database or file other than the current database server. + Scan an index stored in a database or file other than the current database server. + Operator description + + + Remote Index Seek + Remote Index Seek + Operator name + + + Scan a particular range of rows from a clustered index that is stored in a database or file other than the current database server. + Scan a particular range of rows from a clustered index that is stored in a database or file other than the current database server. + Operator description + + + Remote Insert + Remote Insert + Operator name + + + Insert rows into a table stored in a database or file other than the current database server. + Insert rows into a table stored in a database or file other than the current database server. + Operator description + + + Remote Update + Remote Update + Operator name + + + Update rows in a table stored in a database or file other than the current database server. + Update rows in a table stored in a database or file other than the current database server. + Operator description + + + Remote Delete + Remote Delete + Operator name + + + Delete rows in a table stored in a database or file other than the current database server. + Delete rows in a table stored in a database or file other than the current database server. + Operator description + + + Clustered Update + Clustered Update + Operator name + + + Clustered Update. + Clustered Update. + Operator description + + + Sort the input. + Sort the input. + Operator description + + + Stores the data from the input into a temporary table in order to optimize rewinds. + Stores the data from the input into a temporary table in order to optimize rewinds. + Operator description + + + Index Spool + Index Spool + Operator name + + + Reformats the data from the input into a temporary index, which is then used for seeking with the supplied seek predicate. + Reformats the data from the input into a temporary index, which is then used for seeking with the supplied seek predicate. + Operator description + + + Table Update + Table Update + Operator name + + + Update input rows in the table specified in the Argument field. + Update input rows in the table specified in the Argument field. + Operator description + + + Table Insert + Table Insert + Operator name + + + Insert input rows into the table specified in Argument field. + Insert input rows into the table specified in Argument field. + Operator description + + + Table Delete + Table Delete + Operator name + + + Delete input rows from the table specified in Argument field. + Delete input rows from the table specified in Argument field. + Operator description + + + Table Merge + Table Merge + Operator name + + + Merge input rows in the table specified in Argument field. + Merge input rows in the table specified in Argument field. + Operator description + + + Index Update + Index Update + Operator name + + + Update rows in an index. + Update rows in an index. + Operator description + + + Index Insert + Index Insert + Operator name + + + Insert rows into an index. + Insert rows into an index. + Operator description + + + Index Delete + Index Delete + Operator name + + + Delete rows from index. + Delete rows from index. + Operator description + + + Clustered Index Update + Clustered Index Update + Operator name + + + Update rows in a clustered index. + Update rows in a clustered index. + Operator description + + + Clustered Index Insert + Clustered Index Insert + Operator name + + + Insert rows in a clustered index. + Insert rows in a clustered index. + Operator description + + + Clustered Index Merge + Clustered Index Merge + Operator name + + + Merge rows in a clustered index. + Merge rows in a clustered index. + Operator description + + + Clustered Index Delete + Clustered Index Delete + Operator name + + + Delete rows from a clustered index. + Delete rows from a clustered index. + Operator description + + + Select the first few rows based on a sort order. + Select the first few rows based on a sort order. + Operator description + + + Bitmap. + Bitmap. + Operator description + + + UDX + UDX + Operator name + + + UDX. + UDX. + Operator description + + + Expands each row into the set of rows that represent the window associated with it. + Expands each row into the set of rows that represent the window associated with it. + Show plan's Window node property description + + + Window Aggregate + Window Aggregate + Show plan's Window Aggregate node property + + + Computes values of functions across the windows defined by the OVER clause. Input rowset is suitably sorted stream. + Computes values of functions across the windows defined by the OVER clause. Input rowset is suitably sorted stream. + Show plan's Window Aggregate node property description + + + Batch Hash Table Build. + Batch Hash Table Build. + Operator description + + + Switch + Switch + Operator name + + + Switch. + Switch. + Operator description + + + Predict + Predict + Operator name + + + Applies a trained machine learning model to input data + Applies a trained machine learning model to input data + Operator description + + + Table Valued Function + Table Valued Function + Operator name + + + Table valued function. + Table valued function. + Operator description + + + Aggregate + Aggregate + Operator name + + + Calculates an expression containing SUM, COUNT, MIN, MAX, or AVG. + Calculates an expression containing SUM, COUNT, MIN, MAX, or AVG. + Operator description + + + Arithmetic Expression + Arithmetic Expression + Operator name + + + Computes a new value from existing values in a row. + Computes a new value from existing values in a row. + Operator description + + + Delete + Delete + Operator name + + + Removes the specified rows from the specified table. + Removes the specified rows from the specified table. + Operator description + + + Insert + Insert + Operator name + + + Adds a row to table. + Adds a row to table. + Operator description + + + Locate + Locate + Operator name + + + Fetching a full row from a heap or a clustered index. + Fetching a full row from a heap or a clustered index. + Operator description + + + Saving temporarily an intermediate query result. + Saving temporarily an intermediate query result. + Operator description + + + SQL + SQL + Operator name + + + SQL. + SQL. + Operator description + + + Update + Update + Operator name + + + Modify the values in the specified table. + Modify the values in the specified table. + Operator description + + + Assign + Assign + Operator name + + + Validate referential integrity constraints. + Validate referential integrity constraints. + Operator description + + + Convert + Convert + Operator name + + + Implicit or explicit conversion of one scalar datatype to another. + Implicit or explicit conversion of one scalar datatype to another. + Operator description + + + Declare + Declare + Operator name + + + Allocates a local variable. + Allocates a local variable. + Operator description + + + If + If + Operator name + + + Conditional processing based on an expression. + Conditional processing based on an expression. + Operator description + + + Intrinsic + Intrinsic + Operator name + + + Invokes an internal Transact-SQL function. + Invokes an internal Transact-SQL function. + Operator description + + + Set Function + Set Function + Operator name + + + Set Function. + Set Function. + Operator description + + + Dynamic + Dynamic + Operator name + + + Cursor that can see all changes made by others. + Cursor that can see all changes made by others. + Operator description + + + Fetch Query + Fetch Query + Operator name + + + The query used to retrieve rows when a fetch is issued against a cursor. + The query used to retrieve rows when a fetch is issued against a cursor. + Operator description + + + Fast Forward + Fast Forward + Operator name + + + Fast Forward. + Fast Forward. + Operator description + + + Keyset + Keyset + Operator name + + + Cursor that can see updates made by others, but not inserts. + Cursor that can see updates made by others, but not inserts. + Operator description + + + Population Query + Population Query + Operator name + + + The query used to populate a cursor's work table when the cursor is opened. + The query used to populate a cursor's work table when the cursor is opened. + Operator description + + + Refresh Query + Refresh Query + Operator name + + + Fetches current data for rows in fetch buffer. + Fetches current data for rows in fetch buffer. + Operator description + + + Snapshot + Snapshot + Operator name + + + A cursor that does not see changes made by others. + A cursor that does not see changes made by others. + Operator description + + + RID Lookup + RID Lookup + Operator name + + + RID Lookup + RID Lookup + Operator description + + + Key Lookup + Key Lookup + Operator name + + + Uses a supplied clustering key to lookup on a table that has a clustered index. + Uses a supplied clustering key to lookup on a table that has a clustered index. + Operator description + + + Key Lookup + Key Lookup + Operator name + + + Adaptive Join + Adaptive Join + Operator name + + + Chooses dynamically between hash join and nested loops. + Chooses dynamically between hash join and nested loops. + Operator description + + + Foreign Key References Check + Foreign Key References Check + Operator name + + + Checks referential integrity of the delete operation. + Checks referential integrity of the delete operation. + Operator description + + + Apply + Apply + Operator name + + + Apply opration. + Apply opration. + Operator description + + + Broadcast + Broadcast + Operator name + + + Broadcast data movement. + Broadcast data movement. + Operator description + + + Compute To Control Node + Compute To Control Node + Operator name + + + Data flow from compute nodes to control node. + Data flow from compute nodes to control node. + Operator description + + + Constant Table Get + Constant Table Get + Operator name + + + Get tuples from contant table. + Get tuples from contant table. + Operator description + + + Control To Compute Nodes + Control To Compute Nodes + Operator name + + + Data flow from control node to compute nodes. + Data flow from control node to compute nodes. + Operator description + + + External Broadcast + External Broadcast + Operator name + + + Broadcast data movement for external table. + Broadcast data movement for external table. + Operator description + + + External Export + External Export + Operator name + + + Export data movement for external table. + Export data movement for external table. + Operator description + + + External Local Streaming + External Local Streaming + Operator name + + + Streaming data movement between external table and local table. + Streaming data movement between external table and local table. + Operator description + + + External RoundRobin + External RoundRobin + Operator name + + + RoundRobin data movement for external table. + RoundRobin data movement for external table. + Operator description + + + External Shuffle + External Shuffle + Operator name + + + Shuffle data movement for external table. + Shuffle data movement for external table. + Operator description + + + Get + Get + Operator name + + + Get tuples from table. + Get tuples from table. + Operator description + + + Group by and Apply + Group by and Apply + Operator name + + + Group by and Apply. + Group by and Apply. + Operator description + + + Group by Aggregates + Group by Aggregates + Operator name + + + Group by aggregates. + Group by aggregates. + Operator description + + + Join + Join + Operator name + + + Join tables. + Join tables. + Operator description + + + Rollup Aggregate + Rollup Aggregate + Operator name + + + This represents a ROLLUP operator or a CUBE operator. + This represents a ROLLUP operator or a CUBE operator. + Operator description + + + Project + Project + Operator name + + + Project columns. + Project columns. + Operator description + + + Shuffle + Shuffle + Operator name + + + Shuffle data movement. + Shuffle data movement. + Operator description + + + Single Source RoundRobin + Single Source RoundRobin + Operator name + + + Single Source RoundRobin data movement. + Single Source RoundRobin data movement. + Operator description + + + Single Source Shuffle + Single Source Shuffle + Operator name + + + Single Source Shuffle data movement. + Single Source Shuffle data movement. + Operator description + + + Trim + Trim + Operator name + + + Trim data. + Trim data. + Operator description + + + Union + Union + Operator name + + + Union tables. + Union tables. + Operator description + + + Union All + Union All + Operator name + + + Union All tables. + Union All tables. + Operator description + + + {0}: {1} + {0}: {1} + Format for name / value pair - {0} is property name, {1} is property value. + Parameters: 0 - name (string), 1 - value (string) + + + {0} B + {0} B + Size in Bytes format + + + {0} KB + {0} KB + Size in KiloBytes format + + + {0} MB + {0} MB + Size in Bytes format + + + {0} GB + {0} GB + Size in GigaBytes format + + + {0} TB + {0} TB + Size in TeraBytes format + \ No newline at end of file diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ActualPlanDataReaderNodeBuilder.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ActualPlanDataReaderNodeBuilder.cs new file mode 100644 index 00000000..c1418b09 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ActualPlanDataReaderNodeBuilder.cs @@ -0,0 +1,87 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Builds hierarchy of Graph objects from SQL 2000 Actual ShowPlan Record Set + /// + internal class ActualPlanDataReaderNodeBuilder : DataReaderNodeBuilder + { + #region Constructor + + /// + /// Constructs ActualPlanDataReaderNodeBuilder + /// + public ActualPlanDataReaderNodeBuilder() : base() + { + } + + #endregion + + #region Overrides + + protected override ShowPlanType ShowPlanType + { + get { return ShowPlanType.Actual; } + } + + /// + /// Gets index of Node Id in the recordset + /// + protected override int NodeIdIndex + { + get { return 4; } + } + + /// + /// Gets index of Parent Id in the recordset + /// + protected override int ParentIndex + { + get { return 5; } + } + + /// + /// Gets property names that correspond to values returned + /// in each ShowPlan row. + /// + /// Array of property names + protected override string[] GetPropertyNames() + { + return propertyNames; + } + + #endregion + + #region Private members + + private static string[] propertyNames = new string[] + { + NodeBuilderConstants.ActualRows, // Rows + NodeBuilderConstants.ActualExecutions, // Executes + NodeBuilderConstants.StatementText, // StmtText + null, // StmtId + NodeBuilderConstants.NodeId, + null, // Parent + NodeBuilderConstants.PhysicalOp, + NodeBuilderConstants.LogicalOp, + NodeBuilderConstants.Argument, + NodeBuilderConstants.DefinedValues, + NodeBuilderConstants.EstimateRows, + NodeBuilderConstants.EstimateIO, + NodeBuilderConstants.EstimateCPU, + NodeBuilderConstants.AvgRowSize, + NodeBuilderConstants.TotalSubtreeCost, + NodeBuilderConstants.OutputList, + NodeBuilderConstants.Warnings, + NodeBuilderConstants.StatementType, // Type + NodeBuilderConstants.Parallel, + null, // EstimateExecutions + }; + + #endregion + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Attributes.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Attributes.cs new file mode 100644 index 00000000..0bc25c2a --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Attributes.cs @@ -0,0 +1,287 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.ComponentModel; +using System.Diagnostics; +using System.Globalization; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + #region FloatTypeConverter + + /// + /// FloatTypeConverter is used to get a desired float / double representation + /// in the property sheet and the tool tip. + /// The currently used scientific format isn't very readable + /// + /// To use this converter, add the following attribute on top of the property: + /// [TypeConverter(typeof(FloatTypeConverter))] + /// + + public class FloatTypeConverter : TypeConverter + { + /// + /// Converts the object value to another type. + /// In this case the method only supports conversion to string. + /// + /// An ITypeDescriptorContext that provides a format context. + /// A CultureInfo object. If a null reference (Nothing in Visual Basic) is passed, the current culture is assumed. + /// The Object to convert. + /// The Type to convert the value parameter to. + /// The converted value. + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (destinationType == typeof(string)) + { + TypeConverter converter = TypeDescriptor.GetConverter(value); + if (converter.CanConvertTo(typeof(double))) + { + double doubleValue = (double)converter.ConvertTo(value, typeof(double)); + return doubleValue.ToString("0.#######", CultureInfo.CurrentCulture); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } + #endregion + + #region DataSizeTypeConverter + /// + /// DataSizeTypeConverter is used to represent data size in bytes, + /// kilobytes, megabytes, etc., depending on the actual number. + /// + /// To use this converter, add the following attribute on top of the property: + /// [TypeConverter(typeof(DataSizeTypeConverter))] + /// + + public class DataSizeTypeConverter : TypeConverter + { + /// + /// Converts the object value to another type. + /// In this case the method only supports conversion to string. + /// + /// An ITypeDescriptorContext that provides a format context. + /// A CultureInfo object. If a null reference (Nothing in Visual Basic) is passed, the current culture is assumed. + /// The Object to convert. + /// The Type to convert the value parameter to. + /// The converted value. + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + return this.ConvertTo(context, culture, value, destinationType, 0); + } + + /// + /// Converts the object value to another type. + /// In this case the method only supports conversion to string. + /// + /// An ITypeDescriptorContext that provides a format context. + /// A CultureInfo object. If a null reference (Nothing in Visual Basic) is passed, the current culture is assumed. + /// The Object to convert. + /// The Type to convert the value parameter to. + /// The index in size formats to start with. + /// The converted value. + protected object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType, int formatIndex) + { + if (destinationType == typeof(string)) + { + TypeConverter converter = TypeDescriptor.GetConverter(value); + if (converter.CanConvertTo(typeof(double))) + { + double dataSize = (double)converter.ConvertTo(value, typeof(double)); + Debug.Assert(dataSize >= 0, "Data size must not be a negative number."); + + // This cycle finds an optimal range for the size where no more than + // 4 digits are displayed. Furthermore the result is rounded to a neareast + // integer. So it will display sizes up to 9999 bytes in bytes then switch to + // to 10K. Then it will go up to 9999 KB and switch to 10M. + // Please note that 10000 bytes = 9.76 KB and will be rounded to 10 KB. + while (formatIndex < sizeFormats.Length - 1) + { + if ((long)Math.Round(dataSize) < 10000) + { + break; + } + + dataSize /= 1024; + formatIndex++; + } + + return String.Format(culture, sizeFormats[formatIndex], (long)Math.Round(dataSize)); + } + } + + return base.ConvertTo(context, culture, value, destinationType); + } + + static string[] sizeFormats = new string[] + { + SR.SizeInBytesFormat, + SR.SizeInKiloBytesFormat, + SR.SizeInMegaBytesFormat, + SR.SizeInGigaBytesFormat, + SR.SizeInTeraBytesFormat + }; + } + + #endregion + + #region KBSizeTypeConverter + + /// + /// KBSizeTypeConverter is used to represent data size in + /// kilobytes, megabytes, etc., depending on the actual number. + /// Assumes input is in kilobytes + /// + /// To use this converter, add the following attribute on top of the property: + /// [TypeConverter(typeof(KBSizeTypeConverter))] + /// + public sealed class KBSizeTypeConverter : DataSizeTypeConverter + { + /// + /// Converts the object value to another type. + /// In this case the method only supports conversion to string. + /// + /// An ITypeDescriptorContext that provides a format context. + /// A CultureInfo object. If a null reference (Nothing in Visual Basic) is passed, the current culture is assumed. + /// The Object to convert. + /// The Type to convert the value parameter to. + /// The converted value. + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + // formatIndex of 1 indicates value of input should be in KB + return base.ConvertTo(context, culture, value, destinationType, formatIndex: 1); + } + } + + #endregion + + #region DisplayNameAndDescription + + /// + /// Describes property DisplayName and description keywords. + /// + public class DisplayNameDescriptionAttribute : Attribute + { + /// + /// Public default constructor + /// + /// Property DisplayName key. + public DisplayNameDescriptionAttribute(string displayName) + { + this.displayName = displayName; + } + + /// + /// Public default constructor + /// + /// Property DisplayName key. + /// Property Description key. + public DisplayNameDescriptionAttribute(string displayName, string description) + { + this.displayName = displayName; + this.description = description; + } + + /// + /// Gets Display name + /// + public string DisplayName + { + get { return this.displayName; } + } + /// + /// Gets Description + /// + public string Description + { + get { return this.description; } + } + + private string displayName; + private string description; + } + + #endregion + + #region DisplayOrder + + /// + /// Represent order attribute. Tool tip window uses this attribute to sort properties accordingly + /// + public sealed class DisplayOrderAttribute : Attribute + { + /// + /// Public default constructor + /// + /// + public DisplayOrderAttribute(int displayOrder) + { + this.displayOrder = displayOrder; + } + + /// + /// Display order + /// + public int DisplayOrder + { + get { return this.displayOrder; } + } + + private int displayOrder; + } + + #endregion + + #region ShowInToolTip + + /// + /// Represent order attribute. Tool tip window uses this attribute to sort properties accordingly + /// + + public sealed class ShowInToolTipAttribute : Attribute + { + /// + /// Public default constructor. + /// + public ShowInToolTipAttribute() + { + this.value = true; + } + + /// + /// Public constructor. + /// + /// Specifies whether the corresponding property should be visible in tool tips. + /// The default value is true. + public ShowInToolTipAttribute(bool value) + { + this.value = value; + } + + /// + /// True if a property should be shown in ToolTip; otherwise false. + /// + public bool Value + { + get { return this.value; } + } + + /// + /// True if a property is a long string and should take an entire row in a tool tip; otherwise false. + /// + public bool LongString + { + get { return this.longString; } + set { this.longString = value; } + } + + private bool value = true; + private bool longString = false; + } + + #endregion +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Comparison/SkeletonManager.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Comparison/SkeletonManager.cs new file mode 100644 index 00000000..fbdd588a --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Comparison/SkeletonManager.cs @@ -0,0 +1,210 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.Collections.Generic; +using System.Linq; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph.Comparison +{ + /// + /// Handles operations for creating and comparing skeletons of showplan trees + /// A skeleton is the tree with some nodes filtered out to reduce complexity + /// + public class SkeletonManager + { + public SkeletonManager() { } + + /// + /// Constructs a skeleton tree representing logical structure of the showplan + /// Primarily represents joins and data access operators + /// + /// Node to construct skeleton of + /// SkeletonNode with children representing logical descendants of the input node + public SkeletonNode CreateSkeleton(Node root) + { + Node rootNode = root; + var childCount = root.Children.Count; + if (childCount > 1) + { + SkeletonNode skeletonParent = new SkeletonNode(root); + foreach (Node child in root.Children) + { + SkeletonNode skeletonChild = CreateSkeleton(child); + skeletonParent.AddChild(skeletonChild); + } + return skeletonParent; + } + else if (childCount == 1) + { + if (!ShouldIgnoreDuringComparison(rootNode)) + { + // get children recursively then return this node to add it to the skeleton + SkeletonNode skeletonParent = new SkeletonNode(root); + SkeletonNode child = CreateSkeleton(root.Children.ElementAt(0)); + skeletonParent.AddChild(child); + return skeletonParent; + } + // if ignoring root, just go on to the next node + return CreateSkeleton(root.Children.First()); + } + // no children; base case + SkeletonNode skeletonNode = new SkeletonNode(root); + return skeletonNode; + } + + /// + /// Checks root and all children for equivalent tree structure and logical equivalence at the node level + /// + /// + /// + /// + public bool AreSkeletonsEquivalent(SkeletonNode root1, SkeletonNode root2, bool ignoreDatabaseName) + { + if (root1 == null && root2 == null) + return true; + + if (root1 == null || root2 == null) + return false; + + if (!root1.BaseNode.IsLogicallyEquivalentTo(root2.BaseNode, ignoreDatabaseName)) + { + return false; + } + if (root1.Children.Count != root2.Children.Count) + { + return false; + } + var childIterator = 0; + while (childIterator < root1.Children.Count) + { + var checkMatch = AreSkeletonsEquivalent(root1.Children.ElementAt(childIterator), root2.Children.ElementAt(childIterator), ignoreDatabaseName); + if (!checkMatch) + { + // at least one pair of children (ie inner.Child1 & outer.Child1) didn't match; stop checking rest + return false; + } + childIterator++; + } + return true; + } + + /// + /// Finds the largest matching subtrees in two skeletons and colors those subtrees a unique color + /// + /// + /// + public void ColorMatchingSections(SkeletonNode skeleton1, SkeletonNode skeleton2, bool ignoreDatabaseName) + { + // starting node for the outer loop iteration + SkeletonNode outerNode = skeleton1; + Queue outerQueue = new Queue(); + + int groupIndexCounter = 1; + + // Iterates over all nodes in skeleton1 + while (outerNode != null) + { + bool matchFound = false; + SkeletonNode innerNode = skeleton2; + Queue innerQueue = new Queue(); + // to find all the match sleleton2 node for skeleton1, iterate over each node of skeleton2 until all innerNode have been tested, there might be multiple match + while (innerNode != null) + { + if (this.AreSkeletonsEquivalent(outerNode, innerNode, ignoreDatabaseName)) + { + matchFound = true; + int matchColor = groupIndexCounter++; + if (innerNode.ParentNode != null && innerNode.ParentNode.HasMatch) + { + int parentColor = innerNode.ParentNode.GroupIndex; + int innerColor = innerNode.GroupIndex; + // innerNode is the root of a matching subtree, so use its color for the new match instead of the random new color + if (parentColor != innerColor) + { + matchColor = innerColor; + } + } + else if (innerNode.HasMatch) + { + matchColor = innerNode.GroupIndex; + } + else if (outerNode.HasMatch) + { + // outerNode already finds a matching innerNode, but we keep looking for more matching innerNode + matchColor = outerNode.GroupIndex; + } + + outerNode.AddMatchingSkeletonNode(innerNode, ignoreDatabaseName); + innerNode.AddMatchingSkeletonNode(outerNode, ignoreDatabaseName); + outerNode.ChangeSkeletonGroupIndex(matchColor); + innerNode.ChangeSkeletonGroupIndex(matchColor); + } + + // even if we found a matching innerNode, we keep looking since there might be other innerNode that matches same outerNode + foreach (SkeletonNode child in innerNode.Children) + { + innerQueue.Enqueue(child); + } + innerNode = innerQueue.Any() ? innerQueue.Dequeue() : null; + + } + + // no match at all, so add this node's children to queue of nodes to check + // effectively does a bfs - doesn't check children if a match has been found (and the entire subtree colored) + if (!matchFound) + { + foreach (SkeletonNode child in outerNode.Children) + { + outerQueue.Enqueue(child); + } + } + outerNode = outerQueue.Any() ? outerQueue.Dequeue() : null; + } + } + + public Node FindNextNonIgnoreNode(Node node) + { + Node curNode = node; + while (curNode != null && ShouldIgnoreDuringComparison(curNode)) + { + if (curNode.Children.Count > 0) + { + curNode = curNode.Children.ElementAt(0); + } + else + { + // should ignore, but this is a leaf node, so there is no matching node + curNode = null; + } + } + return curNode; + } + + #region Private Methods + + /// + /// Determines if the node should be ignored when building a skeleton of the showplan + /// + /// + /// + private bool ShouldIgnoreDuringComparison(Node node) + { + return IgnoreWhenBuildingSkeleton.Contains(node.Operation.Name) || (node[NodeBuilderConstants.LogicalOp] == null); + } + + #endregion + + /// + /// List of Node names which can safely be ignored when building the skeleton + /// We can ignore these because not finding a matching between them shouldn't imapct of the shaping of matching nodes + /// However, if in the future we see a use case to benefit from matching one of them, for ex I removed Filter because we need it to be skeleton node + /// so we user can find issue for, and jump to the Filter node pair when doing scenario based issue detection + /// + private List IgnoreWhenBuildingSkeleton = new List { SR.Keys.Assert, SR.Keys.BatchHashTableBuild, SR.Keys.Bitmap, SR.Keys.Collapse, SR.Keys.RepartitionStreams, + SR.Keys.ComputeScalar, SR.Keys.MergeInterval, SR.Keys.Parallelism, SR.Keys.Print, SR.Keys.RowCountSpool, SR.Keys.LogicalOpLazySpool, + SR.Keys.TableSpool, SR.Keys.Segment, SR.Keys.SequenceProject, SR.Keys.Split, SR.Keys.Spool, SR.Keys.Window, + SR.Keys.Sort, SR.Keys.Top, SR.Keys.LogicalOpTopNSort }; + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Comparison/SkeletonNode.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Comparison/SkeletonNode.cs new file mode 100644 index 00000000..92af43aa --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Comparison/SkeletonNode.cs @@ -0,0 +1,88 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Linq; +using System.Text; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph.Comparison +{ + public class SkeletonNode + { + public Node BaseNode {get; set;} + public List MatchingNodes { get; set; } + public bool HasMatch { get { return MatchingNodes.Count > 0; } } + public SkeletonNode ParentNode { get; set; } + public IList Children { get; set; } + + public int GroupIndex + { + get + { + return this.BaseNode.GroupIndex; + } + set + { + this.BaseNode.GroupIndex = value; + } + } + + public SkeletonNode(Node baseNode) + { + baseNode[NodeBuilderConstants.SkeletonNode] = this; + this.BaseNode = baseNode; + this.Children = new List(); + this.MatchingNodes = new List(); + } + + /// + /// Adds node to children collection and sets this node as parent of the child + /// + /// + public void AddChild(SkeletonNode child) + { + child.ParentNode = this; + this.Children.Add(child); + } + + public void ChangeSkeletonGroupIndex(int groupIndex) + { + this.GroupIndex = groupIndex; + foreach (SkeletonNode child in this.Children) + { + child.ChangeSkeletonGroupIndex(groupIndex); + } + } + + public void AddMatchingSkeletonNode(SkeletonNode match, bool ignoreDatabaseName, bool matchAllChildren=true) + { + this.BaseNode[NodeBuilderConstants.SkeletonHasMatch] = true; + if (matchAllChildren == true) + { + SkeletonManager manager = new SkeletonManager(); + foreach (SkeletonNode baseChild in this.Children) + { + foreach (SkeletonNode matchChild in match.Children) + { + // make sure this is the right child to match + if (baseChild.BaseNode.IsLogicallyEquivalentTo(matchChild.BaseNode, ignoreDatabaseName)) + { + baseChild.AddMatchingSkeletonNode(matchChild, ignoreDatabaseName, matchAllChildren); + } + } + } + } + this.MatchingNodes.Add(match); + } + + public Graph GetGraph() + { + return this.BaseNode.Graph; + } + + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ConditionParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ConditionParser.cs new file mode 100644 index 00000000..1ff0d72c --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ConditionParser.cs @@ -0,0 +1,54 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.Collections.Generic; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + internal sealed class ConditionParser : XmlPlanHierarchyParser + { + /// + /// Enumerates FunctionType blocks and removes all items from UDF property. + /// + /// The item being parsed. + /// Enumeration. + public override IEnumerable ExtractFunctions(object parsedItem) + { + StmtCondTypeCondition condition = parsedItem as StmtCondTypeCondition; + if (condition != null && condition.UDF != null) + { + foreach (FunctionType function in condition.UDF) + { + yield return new FunctionTypeItem(function, FunctionTypeItem.ItemType.Udf); + } + + condition.UDF = null; + } + } + + /// + /// Private constructor prevents this object from being externally instantiated + /// + private ConditionParser() + { + } + + /// + /// Singelton instance + /// + private static ConditionParser conditionParser = null; + public static new ConditionParser Instance + { + get + { + if (conditionParser == null) + { + conditionParser = new ConditionParser(); + } + return conditionParser; + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/CursorOperationParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/CursorOperationParser.cs new file mode 100644 index 00000000..c6221d62 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/CursorOperationParser.cs @@ -0,0 +1,78 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Parses StmtCursorType ShowPlan XML nodes + /// + internal class CursorOperationParser : XmlPlanParser + { + /// + /// Creates new node and adds it to the graph. + /// + /// Item being parsed. + /// Parent item. + /// Parent node. + /// Node builder context. + /// The node that corresponds to the item being parsed. + public override Node GetCurrentNode(object item, object parentItem, Node parentNode, NodeBuilderContext context) + { + return NewNode(context); + } + + /// + /// Determines Operation that corresponds to the object being parsed. + /// + /// Node being parsed. + /// Operation that corresponds to the node. + protected override Operation GetNodeOperation(Node node) + { + object cursorOperationName = node["OperationType"]; + + Operation cursorOperation = cursorOperationName != null + ? OperationTable.GetPhysicalOperation(cursorOperationName.ToString()) + : Operation.Unknown; + + + return cursorOperation; + } + + /// + /// Determines node subtree cost from existing node properties. + /// + /// Node being parsed. + /// Node subtree cost. + protected override double GetNodeSubtreeCost(Node node) + { + // This node doesn't have subtree cost, so it + // will be determined based on child nodes. + return 0; + } + + /// + /// Private constructor prevents this object from being externally instantiated + /// + private CursorOperationParser() + { + } + + /// + /// Singelton instance + /// + private static CursorOperationParser cursorOperationParser = null; + public static CursorOperationParser Instance + { + get + { + if (cursorOperationParser == null) + { + cursorOperationParser = new CursorOperationParser(); + } + return cursorOperationParser; + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/CursorStatementParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/CursorStatementParser.cs new file mode 100644 index 00000000..cac8f74c --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/CursorStatementParser.cs @@ -0,0 +1,57 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Parses StmtCursorType ShowPlan XML nodes + /// + internal class CursorStatementParser : StatementParser + { + /// + /// Determines Operation that corresponds to the object being parsed. + /// + /// Node being parsed. + /// Operation that corresponds to the node. + protected override Operation GetNodeOperation(Node node) + { + object cursorType = node["CursorActualType"]; + + if (cursorType == null) + { + cursorType = node["StatementType"]; + } + + Operation cursor = cursorType != null + ? OperationTable.GetCursorType(cursorType.ToString()) + : Operation.Unknown; + + return cursor; + } + + /// + /// Private constructor prevents this object from being externally instantiated + /// + private CursorStatementParser() + { + } + + /// + /// Singelton instance + /// + private static CursorStatementParser cursorStatementParser = null; + public static new CursorStatementParser Instance + { + get + { + if (cursorStatementParser == null) + { + cursorStatementParser = new CursorStatementParser(); + } + return cursorStatementParser; + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/DataReaderNodeBuilder.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/DataReaderNodeBuilder.cs new file mode 100644 index 00000000..bb27346f --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/DataReaderNodeBuilder.cs @@ -0,0 +1,296 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Diagnostics; +using System.Globalization; +using System.Text.RegularExpressions; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Base class for building hierarchy of Graph objects from ShowPlan Record Set + /// + internal abstract class DataReaderNodeBuilder: INodeBuilder + { + #region Constructor + + /// + /// Initializes base class members. + /// + /// Show Plan type. + public DataReaderNodeBuilder() + {} + + #endregion + + #region INodeBuilder + + /// + /// Builds one or more Graphs that + /// represnet data from the data source. + /// + /// Data Source. + /// An array of AnalysisServices Graph objects. + public ShowPlanGraph[] Execute(object dataSource) + { + IDataReader reader = dataSource as IDataReader; + + if (reader == null) + { + Debug.Assert(false, "Unexpected ShowPlan source = " + dataSource.GetType().ToString()); + throw new ArgumentException(SR.Keys.UnknownShowPlanSource); + } + + List graphs = new List(); + Dictionary currentGraphNodes = null; + NodeBuilderContext context = null; + + object[] values = null; + string[] names = GetPropertyNames(); + + while (reader.Read()) + { + ReadValues(reader, ref values); + + int nodeID = (int)values[NodeIdIndex]; + int parentNodeID = (int)values[ParentIndex]; + + Node parentNode = null; + + if (parentNodeID == 0) + { + // Starting a new graph + // First add an old graph to the list + if (context != null) + { + graphs.Add(context.Graph); + } + + // Create new Context and new Nodes hashtable + context = new NodeBuilderContext(new ShowPlanGraph(), ShowPlanType, this); + currentGraphNodes = new Dictionary(); + } + else + { + parentNode = currentGraphNodes[parentNodeID]; + } + + // Create new node. + Debug.Assert(context != null); + Node node = CreateNode(nodeID, context); + + ParseProperties(node, names, values); + SetNodeSpecialProperties(node); + + if (parentNode != null) + { + parentNode.Children.AddLast(node); + } + + // Add node to the hashtable + // In some rare cases the graph may already + // contain the node with the same ID. + // This happens, for example, in a case of + // Table Spool node. In this case it is safe + // to not add the node to the currentGraphNodes collection + // because it isn't going to have any children (guaranteed) + if (!currentGraphNodes.ContainsKey(nodeID)) + { + currentGraphNodes.Add(nodeID, node); + } + } + + // Add the last parsed graph to the list of graphs. + if (context != null) + { + graphs.Add(context.Graph); + } + + return graphs.ToArray(); + } + + #endregion + + #region Implementation + + /// + /// Gets property names that correspond to values returned + /// in each ShowPlan row. + /// + /// Array of property names + protected abstract string[] GetPropertyNames(); + + /// + /// Gets index of Node Id in the recordset + /// + protected abstract int NodeIdIndex { get; } + + /// + /// Gets index of Parent Id in the recordset + /// + protected abstract int ParentIndex { get; } + + /// + /// Gets the ShowPlanType of hte resordset + /// + protected abstract ShowPlanType ShowPlanType{ get; } + + /// + /// Sequentially reads all columns from IDataReader + /// + /// + /// + private void ReadValues(IDataReader reader, ref object[] values) + { + if (values == null || reader.FieldCount != values.Length) + { + values = new object[reader.FieldCount]; + } + + // We specifically need to read values sequentially + for (int i = 0; i < values.Length; i++) + { + values[i] = reader.GetValue(i); + } + } + + /// + /// Reads properties from the data row. + /// + /// Node which is populated with properties + /// Property names. + /// Property values. + private void ParseProperties(Node node, string[] names, object[] values) + { + int count = Math.Min(names.Length, values.Length); + + for (int i = 0; i < count; i++) + { + if (names[i] != null && !((values[i] is DBNull) || values[i] == null)) + { + node[names[i]] = values[i]; + } + } + } + + /// + /// Sets special properties on the node. + /// + /// Node. + private static void SetNodeSpecialProperties(Node node) + { + // SubtreeCost is a special property that should be set separately + node.SubtreeCost = GetNodeSubtreeCost(node); + + Operation resultOp; + + string nodeType = (string)node["StatementType"]; + if (string.Compare(nodeType, "PLAN_ROW", StringComparison.OrdinalIgnoreCase) != 0) + { + // This is a statement + resultOp = OperationTable.GetStatement(nodeType); + + node["LogicalOp"] = resultOp.DisplayName; + node["PhysicalOp"] = resultOp.DisplayName; + + // For statements, Argument is the same as the Statement text (if any defined) + node["Argument"] = node["StatementText"]; + } + else + { + // This is an operation node + + // Remove StatementText property + PropertyDescriptor statementTextProperty = node.Properties["StatementText"]; + if (statementTextProperty != null) + { + node.Properties.Remove(statementTextProperty); + } + + // Special consideration for Argument property: + // Try to parse Object name from it + string argument = node["Argument"] as string; + if (argument != null) + { + Match match = argumentObjectExpression.Match(argument); + if (match != Match.Empty) + { + node["Object"] = match.Groups["Object"].Value; + } + } + + string physicalOpType = node["PhysicalOp"] as string; + string logicalOpType = node["LogicalOp"] as string; + + if (physicalOpType == null || logicalOpType == null) + { + throw new FormatException(SR.Keys.UnknownShowPlanSource); + } + + // Remove spaces and other special characters from physical and logical names + physicalOpType = operatorReplaceExpression.Replace(physicalOpType, ""); + logicalOpType = operatorReplaceExpression.Replace(logicalOpType, ""); + + Operation physicalOp = OperationTable.GetPhysicalOperation(physicalOpType); + Operation logicalOp = OperationTable.GetLogicalOperation(logicalOpType); + + resultOp = logicalOp != null && logicalOp.Image != null && logicalOp.Description != null + ? logicalOp : physicalOp; + + node["LogicalOp"] = logicalOp.DisplayName; + node["PhysicalOp"] = physicalOp.DisplayName; + + // EstimateExecutions = EstimateRebinds + EstimateRewinds + 1 + if (node["EstimateRebinds"] != null && node["EstimateRewinds"] != null) + { + double estimateRebinds = (double) node["EstimateRebinds"]; + double estimateRewinds = (double) node["EstimateRewinds"]; + node["EstimateExecutions"] = estimateRebinds + estimateRewinds + 1; + } + + // EstimateRowsAllExecs = EstimateRows * EstimateExecutions + double estimateRows = node["EstimateRows"] == null ? 0.0 : Convert.ToDouble(node["EstimateRows"]); + double estimateExecutions = node["EstimateExecutions"] == null ? 0.0 : Convert.ToDouble(node["EstimateExecutions"]); + double actualExecutions = node["ActualExecutions"] == null ? 0.0 : Convert.ToDouble(node["ActualExecutions"]); + node["EstimateRowsAllExecs"] = estimateRows * estimateExecutions; + } + + Debug.Assert(resultOp.Image != null); + node.Operation = resultOp; + } + + /// + /// 'Factory' method for creating Nodes, allows for subclasses to override + /// + protected virtual Node CreateNode(int nodeId, NodeBuilderContext context) + { + return new Node(nodeId, context); + } + + /// + /// Determines node subtree cost from existing node properties. + /// + /// Node being parsed. + /// Node subtree cost. + private static double GetNodeSubtreeCost(Node node) + { + object value = node["TotalSubtreeCost"]; + return value != null ? Convert.ToDouble(value, CultureInfo.CurrentCulture) : 0; + } + + #endregion + + #region Private members + + private static Regex operatorReplaceExpression = new Regex(@"[ \-]", RegexOptions.CultureInvariant | RegexOptions.Compiled); + private static Regex argumentObjectExpression = new Regex(@"OBJECT:\((?[^\)]*)\)", RegexOptions.CultureInvariant | RegexOptions.Compiled); + + #endregion + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Description.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Description.cs new file mode 100644 index 00000000..f568835c --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Description.cs @@ -0,0 +1,88 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + public class Description + { + #region Properties + + public string Title + { + get { return this.title; } + set + { + this.title = value.Trim().Replace(NewLine, " "); + } + } + + public string QueryText + { + get { return this.queryText; } + set + { + string text = value.Trim(); + this.queryText = text.Replace(NewLine, " "); + } + } + + public string ClusteredMode + { + get { return this.clusteredMode; } + set + { + this.clusteredMode = value.Trim().Replace(NewLine, " "); + } + } + + public bool IsClusteredMode + { + set + { + this.isClusteredMode = value; + } + } + + public bool HasMissingIndex + { + get { return this.hasMissingIndex; } + } + + public string MissingIndexQueryText + { + get { return this.missingIndexQueryText; } + } + + public string MissingIndexImpact + { + get { return this.missingIndexImpact; } + } + + public string MissingIndexDatabase + { + get { return this.missingIndexDatabase; } + } + + #endregion + + #region Member variables + + private string title = string.Empty; + private string queryText = string.Empty; + private string toolTipQueryText = string.Empty; + private string clusteredMode = string.Empty; + private bool isClusteredMode = false; + + private bool hasMissingIndex = false; + private string missingIndexCaption = string.Empty; // actual caption text that will be displayed on the screen + private string missingIndexQueryText = string.Empty; // create index query + private string missingIndexImpact = string.Empty; // impact + private string missingIndexDatabase = string.Empty; // database context + + private const string NewLine = "\r\n"; + + #endregion + } +} \ No newline at end of file diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Edge.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Edge.cs new file mode 100644 index 00000000..0c601353 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Edge.cs @@ -0,0 +1,170 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.ComponentModel; +using System.Globalization; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + public class Edge + { + #region Constructor + + public Node FromNode; + public Node ToNode; + + public Edge(Node fromNode, Node toNode) + { + Initialize(toNode as Node); + } + + #endregion + + #region Public properties and methods + + /// + /// Gets Edge properties. + /// + public PropertyDescriptorCollection Properties + { + get { return this.properties; } + } + + /// + /// Gets or sets node property value. + /// + public object this[string propertyName] + { + get + { + PropertyValue property = this.properties[propertyName] as PropertyValue; + return property != null ? property.Value : null; + } + + set + { + PropertyValue property = this.properties[propertyName] as PropertyValue; + if (property != null) + { + // Overwrite existing property value + property.Value = value; + } + else + { + // Add new property + this.properties.Add(PropertyFactory.CreateProperty(propertyName, value)); + } + } + } + + public double RowSize + { + get + { + object propertyValue = this["AvgRowSize"]; + return propertyValue != null ? Convert.ToDouble(propertyValue, CultureInfo.CurrentCulture) : 0; + } + } + + public double RowCount + { + get + { + if(this["ActualRowsRead"] == null && this["ActualRows"] == null) + { + // If Actual Row count and ActualRowsRead are not set, default to estimated row count + return EstimatedRowCount; + } + else + { + // at least one of ActualRowsRead and ActualRows is set + double actualRowsReadValue = 0; + double actualRowsValue = 0; + if (this["ActualRowsRead"] != null) + { + actualRowsReadValue = Convert.ToDouble(this["ActualRowsRead"].ToString(), CultureInfo.CurrentCulture); + } + if (this["ActualRows"] != null) + { + actualRowsValue = Convert.ToDouble(this["ActualRows"].ToString(), CultureInfo.CurrentCulture); + } + return actualRowsReadValue > actualRowsValue ? actualRowsReadValue : actualRowsValue; + } + } + } + + public double EstimatedRowCount + { + get + { + object propertyValue = this["EstimateRows"]; + if (propertyValue == null) + { + propertyValue = this["StatementEstRows"]; + } + + return propertyValue != null ? Convert.ToDouble(propertyValue, CultureInfo.CurrentCulture) : 0; + } + } + + public double EstimatedDataSize + { + get + { + object propertyValue = this["EstimatedDataSize"]; + return propertyValue != null ? Convert.ToDouble(propertyValue, CultureInfo.CurrentCulture) : 0; + } + + private set + { + this["EstimatedDataSize"] = value; + } + } + + #endregion + + #region Implementation details + + /// + /// Copy some of edge properties from the node connected through this edge. + /// + /// The node connected on the right side of the edge. + private void Initialize(Node node) + { + this.properties = new PropertyDescriptorCollection(new PropertyDescriptor[] {}); + + string[] propertyNames = new string[] + { + "ActualRows", + "ActualRowsRead", + "AvgRowSize", + "EstimateRows", + "EstimateRowsAllExecs", + "StatementEstRows" + }; + + // Copy properties + foreach (string propertyName in propertyNames) + { + object value = node[propertyName]; + if (value != null) + { + this[propertyName] = value; + } + } + + this.EstimatedDataSize = this.RowSize * this.EstimatedRowCount; + } + + #endregion + + #region Private variables + + private PropertyDescriptorCollection properties; + + #endregion + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/EstimatedPlanDataReaderNodeBuilder.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/EstimatedPlanDataReaderNodeBuilder.cs new file mode 100644 index 00000000..2b40399f --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/EstimatedPlanDataReaderNodeBuilder.cs @@ -0,0 +1,86 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Builds hierarchy of Graph objects from SQL 2000 Estimated ShowPlan Record Set + /// + internal sealed class EstimatedPlanDataReaderNodeBuilder : DataReaderNodeBuilder + { + #region Constructor + + /// + /// Constructs EstimatedPlanDataReaderNodeBuilder + /// + public EstimatedPlanDataReaderNodeBuilder() : base() + { + } + + #endregion + + #region Overrides + + protected override ShowPlanType ShowPlanType + { + get { return ShowPlanType.Estimated; } + + } + + /// + /// Gets index of Node Id in the recordset + /// + protected override int NodeIdIndex + { + get { return 2; } + } + + /// + /// Gets index of Parent Id in the recordset + /// + protected override int ParentIndex + { + get { return 3; } + } + + /// + /// Gets property names that correspond to values returned + /// in each ShowPlan row. + /// + /// Array of property names + protected override string[] GetPropertyNames() + { + return propertyNames; + } + + #endregion + + #region Private members + + private static string[] propertyNames = new string[] + { + NodeBuilderConstants.StatementText, // StmtText + null, // StmtId + NodeBuilderConstants.NodeId, + null, // Parent + NodeBuilderConstants.PhysicalOp, + NodeBuilderConstants.LogicalOp, + NodeBuilderConstants.Argument, + NodeBuilderConstants.DefinedValues, + NodeBuilderConstants.EstimateRows, + NodeBuilderConstants.EstimateIO, + NodeBuilderConstants.EstimateCPU, + NodeBuilderConstants.AvgRowSize, + NodeBuilderConstants.TotalSubtreeCost, + NodeBuilderConstants.OutputList, + NodeBuilderConstants.Warnings, + NodeBuilderConstants.StatementType, // Type + NodeBuilderConstants.Parallel, + NodeBuilderConstants.EstimateExecutions + }; + + #endregion + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ExpandableArrayWrapper.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ExpandableArrayWrapper.cs new file mode 100644 index 00000000..61be1752 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ExpandableArrayWrapper.cs @@ -0,0 +1,58 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections; +using System.Globalization; +using System.Text; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + + public class ExpandableArrayWrapper : ExpandableObjectWrapper + { + public ExpandableArrayWrapper(ICollection collection) : base() + { + PopulateProperties(collection); + } + + #region Implementation details + + private void PopulateProperties(ICollection collection) + { + StringBuilder stringBuilder = new StringBuilder(); + int index = 0; + + foreach (object item in collection) + { + if (ObjectWrapperTypeConverter.Default.CanConvertFrom(item.GetType())) + { + object convertedItem = ObjectWrapperTypeConverter.Default.ConvertFrom(item); + if (convertedItem != null) + { + this[GetPropertyName(++index)] = convertedItem; + + if (stringBuilder.Length > 0) + { + stringBuilder.Append(CultureInfo.CurrentCulture.TextInfo.ListSeparator); + stringBuilder.Append(" "); + } + + stringBuilder.Append(convertedItem.ToString()); + } + } + } + + this.DisplayName = stringBuilder.ToString(); + } + + public static string GetPropertyName(int index) + { + return String.Format(CultureInfo.CurrentCulture, "[{0}]", index); + } + + #endregion + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ExpandableObjectWrapper.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ExpandableObjectWrapper.cs new file mode 100644 index 00000000..44442372 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ExpandableObjectWrapper.cs @@ -0,0 +1,169 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.ComponentModel; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + public class ExpandableObjectWrapper : ObjectParser, ICustomTypeDescriptor + { + public ExpandableObjectWrapper() + : this(null, null, String.Empty) + { + } + + public ExpandableObjectWrapper(object item) + : this(item, null) + { + } + + public ExpandableObjectWrapper(object item, string defaultPropertyName) + : this(item, defaultPropertyName, GetDefaultDisplayName(item)) + { + } + + public ExpandableObjectWrapper(object item, string defaultPropertyName, string displayName) + { + this.properties = new PropertyDescriptorCollection(new PropertyDescriptor[]{}); + + if (item != null) + { + ParseProperties(item, this.properties, null); + } + + if (defaultPropertyName != null) + { + defaultProperty = this.properties[defaultPropertyName]; + } + + this.displayName = displayName; + } + + /// + /// Gets or sets node property value. + /// + public object this[string propertyName] + { + get + { + PropertyValue property = this.properties[propertyName] as PropertyValue; + return property != null ? property.Value : null; + } + + set + { + PropertyValue property = this.properties[propertyName] as PropertyValue; + if (property != null) + { + // Overwrite existing property value + property.Value = value; + } + else + { + // Add new property + this.properties.Add(new PropertyValue(propertyName, value)); + } + } + } + + [Browsable(false)] + public string DisplayName + { + get { return this.displayName; } + set { this.displayName = value; } + } + + [Browsable(false)] + public PropertyDescriptorCollection Properties + { + get { return this.properties; } + } + + public override string ToString() + { + return this.displayName; + } + + /// + /// Gets the result of item.ToString if it isn't the item class name. + /// + /// Item to stringize. + /// Default item display name. + public static string GetDefaultDisplayName(object item) + { + string itemString = item.ToString(); + return itemString != item.GetType().ToString() ? itemString : String.Empty; + } + + #region ICustomTypeDescriptor + + AttributeCollection ICustomTypeDescriptor.GetAttributes() + { + return TypeDescriptor.GetAttributes(GetType()); + } + + EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() + { + return TypeDescriptor.GetDefaultEvent(GetType()); + } + + PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() + { + return defaultProperty; + } + + object ICustomTypeDescriptor.GetEditor(Type editorBaseType) + { + return TypeDescriptor.GetEditor(GetType(), editorBaseType); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents() + { + return TypeDescriptor.GetEvents(GetType()); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) + { + return TypeDescriptor.GetEvents(GetType(), attributes); + } + + object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) + { + return this; + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() + { + return this.properties; + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) + { + return this.properties; + } + + string ICustomTypeDescriptor.GetComponentName() + { + return null; + } + + TypeConverter ICustomTypeDescriptor.GetConverter() + { + return TypeDescriptor.GetConverter(GetType()); + } + + string ICustomTypeDescriptor.GetClassName() + { + return GetType().Name; + } + + #endregion + + private PropertyDescriptorCollection properties; + private PropertyDescriptor defaultProperty; + private string displayName; + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/FilterTypeParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/FilterTypeParser.cs new file mode 100644 index 00000000..4c644efc --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/FilterTypeParser.cs @@ -0,0 +1,62 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.ComponentModel; +using System.Diagnostics; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Parses ShowPlan XML objects derived from RelOpBaseType type + /// + internal sealed class FilterTypeParser : RelOpBaseTypeParser + { + /// + /// Private constructor prevents this object from being externally instantiated + /// + private FilterTypeParser() + { + } + + /// + /// Updates node special properties. + /// + /// Node being parsed. + public override void ParseProperties(object parsedItem, PropertyDescriptorCollection targetPropertyBag, NodeBuilderContext context) + { + base.ParseProperties(parsedItem, targetPropertyBag, context); + + FilterType item = parsedItem as FilterType; + Debug.Assert(item != null, "FilterType object expected"); + + if (item.StartupExpression) + { + // If the filter has Predicate property, it has to be renamed to + // Startup Expression Predicate + PropertyValue property = targetPropertyBag["Predicate"] as PropertyValue; + if (property != null) + { + property.SetDisplayNameAndDescription(SR.StartupExpressionPredicate, null); + } + } + } + + /// + /// Singelton instance + /// + private static FilterTypeParser filterTypeParser = null; + public static new FilterTypeParser Instance + { + get + { + if (filterTypeParser == null) + { + filterTypeParser = new FilterTypeParser(); + } + return filterTypeParser; + } + } + } +} \ No newline at end of file diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/FunctionTypeParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/FunctionTypeParser.cs new file mode 100644 index 00000000..575126a1 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/FunctionTypeParser.cs @@ -0,0 +1,91 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.ComponentModel; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + internal sealed class FunctionTypeParser : XmlPlanParser + { + /// + /// This function doesn't do anything. It simply returns the parent node + /// passed it. + /// + /// Item being parsed. + /// Parent item. + /// Parent node. + /// Node builder context. + /// The node that corresponds to the item being parsed. + public override Node GetCurrentNode(object item, object parentItem, Node parentNode, NodeBuilderContext context) + { + Node currentNode = NewNode(context); + + bool isStoredProcedure = false; + + if (parentItem != null) + { + PropertyDescriptor storedProcProperty = TypeDescriptor.GetProperties(parentItem)["StoredProc"]; + + // If parent item has "StoredProc" property and it references the current item + // then this item is a Stored Procedure. Otherwise it is an UDF. + if (storedProcProperty != null && storedProcProperty.GetValue(parentItem) == item) + { + isStoredProcedure = true; + } + } + + currentNode.Operation = isStoredProcedure ? OperationTable.GetStoredProc() : OperationTable.GetUdf(); + + return currentNode; + } + + /// + /// Determines Operation that corresponds to the object being parsed. + /// + /// Node being parsed. + /// Operation that corresponds to the node. + protected override Operation GetNodeOperation(Node node) + { + + // Node operation is defined above based on parent item. + return null; + } + + /// + /// Determines node subtree cost from existing node properties. + /// + /// Node being parsed. + /// Node subtree cost. + protected override double GetNodeSubtreeCost(Node node) + { + // This node doesn't have subtree cost, so it + // will be determined based on child nodes. + return 0; + } + + /// + /// Private constructor prevents this object from being externally instantiated + /// + private FunctionTypeParser() + { + } + + /// + /// Singelton instance + /// + private static FunctionTypeParser functionTypeParser = null; + public static FunctionTypeParser Instance + { + get + { + if (functionTypeParser == null) + { + functionTypeParser = new FunctionTypeParser(); + } + return functionTypeParser; + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Graph.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Graph.cs new file mode 100644 index 00000000..8461d346 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Graph.cs @@ -0,0 +1,14 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + public class Graph + { + public Node Root; + + public Description Description; + } +} \ No newline at end of file diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/INodeBuilder.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/INodeBuilder.cs new file mode 100644 index 00000000..4ddbb134 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/INodeBuilder.cs @@ -0,0 +1,25 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Interface represents an abstract builder that gets + /// data from the data source and represents it as + /// an array of AnalysisServices Graph objects. + /// + public interface INodeBuilder + { + /// + /// Builds one or more Graphs that + /// represnet data from the data source. + /// + /// Data Source. + /// An array of AnalysisServices Graph objects. + ShowPlanGraph[] Execute(object dataSource); + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/IXmlBatchParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/IXmlBatchParser.cs new file mode 100644 index 00000000..71e54664 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/IXmlBatchParser.cs @@ -0,0 +1,31 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Interface represents ability to split an data source containing multiple + /// batches / statement into statements and return an XML containing a single statement. + /// This is used for XML ShowPlan saving. + /// + public interface IXmlBatchParser + { + /// + /// Builds one or more Graphs that + /// represnet data from the data source. + /// + /// Data Source. + /// An array of AnalysisServices Graph objects. + string GetSingleStatementXml(object dataSource, int statementIndex); + + /// + /// Returns statements block type object + /// + /// Data source + /// Statement index in the data source + /// Statement block type object + StmtBlockType GetSingleStatementObject(object dataSource, int statementIndex); + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/IndexOpTypeParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/IndexOpTypeParser.cs new file mode 100644 index 00000000..640c7285 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/IndexOpTypeParser.cs @@ -0,0 +1,113 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.ComponentModel; +using System.Diagnostics; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Parses ShowPlan XML objects derived from RelOpBaseType type + /// + internal sealed class IndexOpTypeParser : RelOpBaseTypeParser + { + /// + /// Private constructor prevents this object from being externally instantiated + /// + private IndexOpTypeParser() + { + } + + /// + /// Singelton instance + /// + private static IndexOpTypeParser indexOpTypeParser = null; + public static new IndexOpTypeParser Instance + { + get + { + if (indexOpTypeParser == null) + { + indexOpTypeParser = new IndexOpTypeParser(); + } + return indexOpTypeParser; + } + } + + + /// + /// Retrieves the ObjectType that the Index operation references. + /// + /// The current Index operation node being parsed + private ObjectType GetObjectTypeFromProperties(object parsedItem) + { + ObjectType objectType = null; + + // The index operators operate on an object, get that object. + PropertyDescriptor objectProperty = TypeDescriptor.GetProperties(parsedItem)["Object"]; + Debug.Assert(objectProperty != null, "Object expected"); + if (objectProperty != null) + { + object objectItem = objectProperty.GetValue(parsedItem); + if (objectItem != null) + { + ObjectType[] objectTypeArray = objectItem as ObjectType[]; + Debug.Assert(objectTypeArray != null && objectTypeArray.Length == 1, "ObjectTypeArray is null or more than one object found for IndexScan"); + + // Only handle the index operations operate on one object + if (objectTypeArray != null && objectTypeArray.Length == 1) + { + objectType = objectTypeArray[0]; + } + } + } + + return objectType; + } + + /// + /// Adds the indexKind attribute, if it exists, from the ObjectType as a property in the targetPropertyBag. + /// + /// The objectType for the indexScan. + /// The target the property bag where we will put the PhysicalOperationKind element. + private void AddIndexKindAsPhysicalOperatorKind(ObjectType objectType, PropertyDescriptorCollection targetPropertyBag) + { + if (objectType.IndexKindSpecified) + { + if (0 < objectType.IndexKind.ToString().Length) + { + PropertyDescriptor wrapperProperty = PropertyFactory.CreateProperty("PhysicalOperationKind", objectType.IndexKind.ToString()); + if (wrapperProperty != null) + { + targetPropertyBag.Add(wrapperProperty); + } + } + } + } + + + /// + /// Updates node special properties. + /// + /// Node being parsed. The node should be IndexScanType or CreateIndexType + public override void ParseProperties(object parsedItem, PropertyDescriptorCollection targetPropertyBag, NodeBuilderContext context) + { + Debug.Assert((parsedItem is IndexScanType) || (parsedItem is CreateIndexType), "IndexScanType or CreateIndexType object expected"); + + // Parse the item as usual with RelOpBaseTypeParser first + base.ParseProperties(parsedItem, targetPropertyBag, context); + + // Now look for the object and get the indexKind + if ((parsedItem is IndexScanType) || (parsedItem is CreateIndexType)) + { + ObjectType objectType = this.GetObjectTypeFromProperties(parsedItem); + if (objectType != null) + { + this.AddIndexKindAsPhysicalOperatorKind(objectType, targetPropertyBag); + } + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/MergeTypeParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/MergeTypeParser.cs new file mode 100644 index 00000000..6e656a77 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/MergeTypeParser.cs @@ -0,0 +1,106 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.ComponentModel; +using System.Diagnostics; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Parses ShowPlan XML objects derived from RelOpBaseType type + /// + internal sealed class MergeTypeParser : RelOpBaseTypeParser + { + /// + /// Private constructor prevents this object from being externally instantiated + /// + private MergeTypeParser() + { + } + + /// + /// Updates node special properties. + /// + /// Node being parsed. + public override void ParseProperties(object parsedItem, PropertyDescriptorCollection targetPropertyBag, NodeBuilderContext context) + { + base.ParseProperties(parsedItem, targetPropertyBag, context); + + MergeType item = parsedItem as MergeType; + Debug.Assert(item != null, "MergeType object expected"); + + // Make a new property which combines "InnerSideJoinColumns" and "OuterSideJoinColumns" + object mergeColumnsWrapper = ObjectWrapperTypeConverter.Convert(new MergeColumns(item)); + PropertyDescriptor wrapperProperty = PropertyFactory.CreateProperty("WhereJoinColumns", mergeColumnsWrapper); + if (wrapperProperty != null) + { + targetPropertyBag.Add(wrapperProperty); + } + } + + /// + /// Indicates if a property should be skipped from the target property bag + /// + /// + /// + protected override bool ShouldSkipProperty(PropertyDescriptor property) + { + if (property.Name == "InnerSideJoinColumns" || property.Name == "OuterSideJoinColumns") + { + // These two properties are handled in a special way + return true; + } + + return base.ShouldSkipProperty(property); + } + + + /// + /// Singelton instance + /// + private static MergeTypeParser mergeTypeParser = null; + public static new MergeTypeParser Instance + { + get + { + if (mergeTypeParser == null) + { + mergeTypeParser = new MergeTypeParser(); + } + return mergeTypeParser; + } + } + } + + /// + /// This type is used for 2 purposes: + /// 1) It creates additional level in the property hierarchy. Instead of including + /// InnerSideJoinColumns and OuterSideJoinColumnsField properties in the Node, we + /// create additional property which has these two properties as nested properties. + /// 2) It allows to convert this to string the same way we convert other custom types + /// See static Convert(MergeColumns) method in ObjectWrapperTypeConverter.cs + /// + public sealed class MergeColumns + { + public MergeColumns(MergeType mergeType) + { + this.innerSideJoinColumnsField = mergeType.InnerSideJoinColumns; + this.outerSideJoinColumnsField = mergeType.OuterSideJoinColumns; + } + + public ColumnReferenceType[] InnerSideJoinColumns + { + get { return this.innerSideJoinColumnsField; } + } + + public ColumnReferenceType[] OuterSideJoinColumns + { + get { return this.outerSideJoinColumnsField; } + } + + private ColumnReferenceType[] innerSideJoinColumnsField; + private ColumnReferenceType[] outerSideJoinColumnsField; + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Node.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Node.cs new file mode 100644 index 00000000..87671155 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Node.cs @@ -0,0 +1,398 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections.Generic; +using System.ComponentModel; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Status of operator + /// Based on the query profile DMV view + /// Pending: when FirstRowTime > 0, Running: FirstRowTime > 0 && CloseTime ==0, Finish: CloseTime > 0 + /// + public enum STATUS + { + PENDING, + RUNNING, + FINISH + } + + public class Node + { + #region Constructor + + public Node(int id, NodeBuilderContext context) + { + this.ID = id; + this.properties = new PropertyDescriptorCollection(new PropertyDescriptor[0]); + this.children = new LinkedList(); + this.childrenEdges = new LinkedList(); + this.LogicalOpUnlocName = null; + this.PhysicalOpUnlocName = null; + this.root = context.Graph.Root; + if(this.root == null) + { + this.root = this; + } + this.Graph = context.Graph; + } + + #endregion + + #region Public methods and properties + + public int ID + { + get; set; + } + + public int GroupIndex + { + get; set; + } + + /// + /// Gets the cost associated with the current Node. + /// + public double Cost + { + get + { + if (!this.costCalculated) + { + this.cost = this.SubtreeCost; + foreach (Node childNode in this.Children) + { + this.cost -= childNode.SubtreeCost; + } + + // In some cases cost may become a small negative + // number due to rounding. Make it 0 in that case. + this.cost = Math.Max(this.cost, 0.0); + this.costCalculated = true; + } + + return this.cost; + } + } + + /// + /// Gets the relative cost associated with the current Node. + /// + public double RelativeCost + { + get + { + double overallCost = Root.SubtreeCost; + return overallCost > 0 ? Cost / overallCost : 0; + } + } + + /// + /// Gets the cost associated with the Node subtree. + /// + public double SubtreeCost + { + get + { + if (this.subtreeCost == 0) + { + foreach (Node childNode in this.Children) + { + this.subtreeCost += childNode.SubtreeCost; + } + } + + return this.subtreeCost; + } + + set + { + this.subtreeCost = value; + } + } + + /// + /// Gets the operation information (localized name, description, image, etc) + /// + public Operation Operation + { + get { return this.operation; } + set { this.operation = value; } + } + + /// + /// Gets node properties. + /// + public PropertyDescriptorCollection Properties + { + get { return this.properties; } + } + + /// + /// Gets or sets node property value. + /// + public object this[string propertyName] + { + get + { + PropertyValue property = this.properties[propertyName] as PropertyValue; + return property != null ? property.Value : null; + } + + set + { + PropertyValue property = this.properties[propertyName] as PropertyValue; + if (property != null) + { + // Overwrite existing property value + property.Value = value; + } + else + { + // Add new property + this.properties.Add(PropertyFactory.CreateProperty(propertyName, value)); + } + } + } + + public bool IsComputeScalarType() + { + return this[NodeBuilderConstants.PhysicalOp] != null + && ((string)this[NodeBuilderConstants.PhysicalOp]).StartsWith(SR.Keys.ComputeScalar, StringComparison.OrdinalIgnoreCase); + } + + public bool IsSeekOrScanType() + { + return this[NodeBuilderConstants.PhysicalOp] != null && SeekOrScanPhysicalOpList.Contains(this.PhysicalOpUnlocName); + } + + /// + /// Gets collection of node children. + /// + public LinkedList Children + { + get { return this.children; } + } + + /// + /// Gets current node parent. + /// + public Node Parent + { + get; + } + + public Node Root + { + get { return this.root; } + } + + public Graph Graph + { + get => this.graph; + set + { + this.graph = value; + } + } + + /// + /// Identifies if this node is finished executing + /// + /// True if finished + public bool IsFinished() + { + var statusObject = this[NodeBuilderConstants.Status] as STATUS?; + + return statusObject != null && (STATUS)statusObject == STATUS.FINISH; + } + + /// + /// Identifies if this node is executing + /// + /// True if running + public bool IsRunning() + { + var statusObject = this[NodeBuilderConstants.Status] as STATUS?; + + return statusObject != null && (STATUS)statusObject == STATUS.RUNNING; + } + + /// + /// Returns whether the properties of two nodes are logically similar enough to be considered + /// the same for skeleton comparison purposes + /// Does not check children + /// + /// + /// + /// + /// + public bool IsLogicallyEquivalentTo(Node nodeToCompare, bool ignoreDatabaseName) + { + // same exact node + if (this == nodeToCompare) + return true; + + // seek and scan types are equivalent so ignore them when comparing logical op + if (this[NodeBuilderConstants.LogicalOp] != nodeToCompare[NodeBuilderConstants.LogicalOp] && + (!this.IsSeekOrScanType() || !nodeToCompare.IsSeekOrScanType())) + return false; + + // one has object but other does not + if (this[objectProperty] != null && nodeToCompare[objectProperty] == null || nodeToCompare[objectProperty] != null && this[objectProperty] == null) + return false; + + // both have object + if (this[objectProperty] != null && nodeToCompare[objectProperty] != null) + { + ExpandableObjectWrapper objectProp1 = (ExpandableObjectWrapper)this[objectProperty]; + ExpandableObjectWrapper objectProp2 = (ExpandableObjectWrapper)nodeToCompare[objectProperty]; + // object property doesn't match + // by default, we ignore DB name + // for ex: "[master].[sys].[sysobjvalues].[clst] [e]" and "[master_copy].[sys].[sysobjvalues].[clst] [e]" would be same + if (ignoreDatabaseName) + { + if (!CompareObjectPropertyValue((PropertyValue)(objectProp1.Properties[SR.ObjectServer]), (PropertyValue)(objectProp2.Properties[SR.ObjectServer]))) + { + return false; + } + if (!CompareObjectPropertyValue((PropertyValue)(objectProp1.Properties[SR.ObjectSchema]), (PropertyValue)(objectProp2.Properties[SR.ObjectSchema]))) + { + return false; + } + if (!CompareObjectPropertyValue((PropertyValue)(objectProp1.Properties[SR.ObjectTable]), (PropertyValue)(objectProp2.Properties[SR.ObjectTable]))) + { + return false; + } + if (!CompareObjectPropertyValue((PropertyValue)(objectProp1.Properties[SR.ObjectAlias]), (PropertyValue)(objectProp2.Properties[SR.ObjectAlias]))) + { + return false; + } + + // check for CloneAccessScope if it is specified + PropertyValue specified1 = (PropertyValue)(objectProp1.Properties["CloneAccessScopeSpecified"]); + PropertyValue specified2 = (PropertyValue)(objectProp2.Properties["CloneAccessScopeSpecified"]); + if (specified1 == null && specified2 != null || specified1 != null && specified2 == null) + { + return false; + } + else if (specified1 != null && specified2 != null) + { + if ((bool)(specified1.Value) != (bool)(specified2.Value)) + { + return false; + } + else + { + if ((bool)(specified1.Value) == true) + { + PropertyValue p1 = (PropertyValue)(objectProp1.Properties["CloneAccessScope"]); + PropertyValue p2 = (PropertyValue)(objectProp2.Properties["CloneAccessScope"]); + if (p1 == null && p2 != null || p1 != null && p2 == null) + { + return false; + } + else if (p1 != null && p2 != null) + { + if ((CloneAccessScopeType)(p1.Value) != (CloneAccessScopeType)(p2.Value)) + { + return false; + } + } + } + } + } + } + else + { + if (objectProp1.DisplayName != objectProp2.DisplayName) + { + return false; + } + } + } + // same logical op, no other criteria + return true; + } + + /// + /// ENU name for Logical Operator + /// + public string LogicalOpUnlocName { get; set; } + + /// + /// ENU name for Physical Operator + /// + public string PhysicalOpUnlocName { get; set; } + + #endregion + + #region Implementation details + + /// + /// used to compare multiple string type PropertyValue in Object properties, + /// for ex: Server, Database, Schema, Table, Index, etc... + /// + /// True if two PropertyValue are equal + private bool CompareObjectPropertyValue(PropertyValue p1, PropertyValue p2) + { + if (p1 == null && p2 != null || p1 != null && p2 == null) + { + return false; + } + else if (p1 != null && p2 != null) + { + string s1 = p1.Value as string; + string s2 = p2.Value as string; + if (string.Compare(s1, s2, StringComparison.Ordinal) != 0) + { + return false; + } + } + + return true; + } + + #endregion + + #region Private variables + + private double cost; + private bool costCalculated; + private double subtreeCost; + private Operation operation; + private PropertyDescriptorCollection properties; + private LinkedList children; + private readonly string objectProperty = NodeBuilderConstants.Object; + private readonly string predicateProperty = NodeBuilderConstants.LogicalOp; + private Node parent; + private Graph graph; + private Edge parentEdge; + private LinkedList childrenEdges; + private string nodeType; + + private Node root; + + /// + /// List of Seek or Scan type operators that can be considered match + /// + private List SeekOrScanPhysicalOpList = new List { "IndexSeek", "TableScan", "IndexScan", "ColumnstoreIndexScan" }; + + #endregion + + public void AddChild(Node child) + { + Edge edge = new Edge(this, child); + this.childrenEdges.AddLast(edge); + child.parentEdge = edge; + this.children.AddLast(child); + child.parent = this; + } + + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/NodeBuilderContext.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/NodeBuilderContext.cs new file mode 100644 index 00000000..a1b91c6e --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/NodeBuilderContext.cs @@ -0,0 +1,45 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + public class NodeBuilderContext + { + public NodeBuilderContext(ShowPlanGraph graph, ShowPlanType type, object context) + { + this.graph = graph; + this.showPlanType = type; + this.context = context; + } + + /// + /// Gets currently processing Graph + /// + public ShowPlanGraph Graph + { + get { return this.graph; } + } + + /// + /// Gets current ShowPlan type. + /// + public ShowPlanType ShowPlanType + { + get { return this.showPlanType; } + } + + /// + /// Misc context object. + /// + public object Context + { + get { return this.context; } + } + + private ShowPlanGraph graph; + private ShowPlanType showPlanType; + private object context; + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/NodeBuilderFactory.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/NodeBuilderFactory.cs new file mode 100644 index 00000000..2510fd33 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/NodeBuilderFactory.cs @@ -0,0 +1,57 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Data; +using System.Diagnostics; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Class that creates concrete INodeBuilder instances. + /// + public static class NodeBuilderFactory + { + /// + /// Instantiates a concrete node builder based on dataSource type + /// + /// data + /// + public static INodeBuilder Create(object dataSource, ShowPlanType type) + { + if (dataSource is String || dataSource is byte[] || dataSource is ShowPlanXML) + { + // REVIEW: add the code that looks inside the XML + // and validates the root node and namespace + // REVIEW: consider using XmlTextReader + return new XmlPlanNodeBuilder(type); + } + else if (dataSource is IDataReader) + { + // REVIEW: for now the assumption is that this is + // a Shiloh Row set, either actual or estimated + if (type == ShowPlanType.Actual) + { + return new ActualPlanDataReaderNodeBuilder(); + } + else if (type == ShowPlanType.Estimated) + { + return new EstimatedPlanDataReaderNodeBuilder(); + } + // else if (type == ShowPlanType.Live) + // { + // return new LivePlanDataReaderNodeBuilder(); + // } + else + { + Debug.Assert(false, "Unexpected ShowPlan type"); + } + } + + Debug.Assert(false, "Unexpected ShowPlan source = " + dataSource.ToString()); + throw new ArgumentException(SR.Keys.UnknownShowPlanSource); + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ObjectParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ObjectParser.cs new file mode 100644 index 00000000..9feb0e1c --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ObjectParser.cs @@ -0,0 +1,111 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.ComponentModel; +using System.Collections; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Base class for all object / Node parsers + /// Used for parsing properties and hierarchy. + /// + public abstract class ObjectParser + { + /// + /// Parses item properties. + /// + /// Item which properties are being parsed. + /// Target property bag to populate with property wrappers. + /// Node builder context. + public virtual void ParseProperties(object parsedItem, PropertyDescriptorCollection targetPropertyBag, NodeBuilderContext context) + { + PropertyDescriptorCollection allProperties = TypeDescriptor.GetProperties(parsedItem); + + + + foreach (PropertyDescriptor property in allProperties) + { + if (property.Attributes.Contains(XmlIgnoreAttribute)) + { + continue; + } + + // a special "...Specified" property (such as StatementIdSpecified) + PropertyDescriptor specifiedProperty = allProperties[property.Name + "Specified"]; + if (specifiedProperty != null && specifiedProperty.GetValue(parsedItem).Equals(false)) + { + // The "...Specified" property value is false. + // We should skip this property + continue; + } + + object value = property.GetValue(parsedItem); + if (value == null) + { + continue; + } + + if (Type.GetTypeCode(property.PropertyType) == TypeCode.Object && ShouldSkipProperty(property)) + { + continue; + } + + // In case of xml Choice group, the property name can be general like "Item" or "Items". + // Ideally, it should contain/refer to only one of the possible values in xml choice group, + // but due to limitations on engine side the xml choice group can contain more than one + // value and it is not possible to change the choice group to a sequence group in XSD + // because engine is not able to generate values in a particular order for the case of + // warnings type. Hence, we need to iterate through all the values in items and create + // separate property for each value and add it to target property bag. + if (property.Name == "Items" || property.Name == "Item") + { + ICollection collection = value as ICollection; + if (collection != null) + { + foreach (object obj in collection) + { + ObjectParser.AddProperty(targetPropertyBag, property, obj); + } + } + else + { + //We can get single object in choice like SeekPredicateNew in Spool as Item + ObjectParser.AddProperty(targetPropertyBag, property, value); + } + } + else + { + ObjectParser.AddProperty(targetPropertyBag, property, value); + } + } + } + + private static void AddProperty(PropertyDescriptorCollection targetPropertyBag, PropertyDescriptor property, object value) + { + PropertyDescriptor wrapperProperty = PropertyFactory.CreateProperty(property, value); + if (wrapperProperty != null) + { + targetPropertyBag.Add(wrapperProperty); + } + } + + /// + /// Determines if the current property is used to reference a child item. + /// Hierarchy properties are skipped when property wrappers are being created. + /// + /// Property subject to test. + /// True if the property is a hierarchy property; + /// false if this is a regular property that should appear in the property grid. + /// + protected virtual bool ShouldSkipProperty(PropertyDescriptor property) + { + return false; + } + + private static readonly Attribute XmlIgnoreAttribute = new System.Xml.Serialization.XmlIgnoreAttribute(); + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ObjectWrapperTypeConverter.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ObjectWrapperTypeConverter.cs new file mode 100644 index 00000000..99338c37 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/ObjectWrapperTypeConverter.cs @@ -0,0 +1,1109 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections; +using System.Collections.Generic; +using System.ComponentModel; +using System.Globalization; +using System.IO; +using System.Reflection; +using System.Text; +using System.Xml; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// This class converts methods for converting from ShowPlanXML native classes + /// such as ColumnReferenceType or DefinedValuesListTypeDefinedValue to + /// ShowPlan control types used in UI such as string or ExpandableObjectWrapper. + /// + /// The actual Conversion is done within multiple static Convert methods which are + /// invoked dynamically via reflection. There is code in the static constructor which + /// discovers all Convert methods and stores them in a hash table using the type + /// to convert from as a key. + /// If you need to add a new conversion type, you typically just need to add a new + /// Convert() method. + /// + internal class ObjectWrapperTypeConverter : ExpandableObjectConverter + { + /// + /// Default instance + /// + public static ObjectWrapperTypeConverter Default = new ObjectWrapperTypeConverter(); + + /// + /// Default converter to ExpandableObjectWrapper + /// + /// + /// + public static ExpandableObjectWrapper ConvertToWrapperObject(object item) + { + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(item); + wrapper.DisplayName = MakeDisplayNameFromObjectNamesAndValues(wrapper); + return wrapper; + } + + #region Specific converters + + /// + /// Converts ColumnReferenceType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(ColumnReferenceType item) + { + string displayName = MergeString(".", item.Database, item.Schema, item.Table, item.Column); + return new ExpandableObjectWrapper(item, "Column", displayName); + } + + /// + /// Converts GroupingSetReferenceType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(GroupingSetReferenceType item) + { + string displayName = item.Value; + return new ExpandableObjectWrapper(item, "GroupingSet", displayName); + } + + /// + /// Converts ObjectType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(ObjectType item) + { + string displayName = MergeString(".", item.Server, item.Database, item.Schema, item.Table, item.Index); + displayName = MergeString(" ", displayName, item.Alias); + if (item.CloneAccessScopeSpecified) + { + string cloneAccessScope = ObjectWrapperTypeConverter.Convert(item.CloneAccessScope); + displayName = MergeString(" ", displayName, cloneAccessScope); + } + return new ExpandableObjectWrapper(item, "Index", displayName); + } + + /// + /// Converts ObjectType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(SingleColumnReferenceType item) + { + return Convert(item.ColumnReference); + } + + /// + /// Converts array of DefinedValuesListTypeDefinedValue to a wrapper array. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(DefinedValuesListTypeDefinedValue[] definedValues) + { + // Note that DefinedValuesListTypeDefinedValue has both Item and Items properties. + // Each Item gets converted to property name, while Items converted to property value. + + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(); + StringBuilder stringBuilder = new StringBuilder(); + + foreach (DefinedValuesListTypeDefinedValue definedValue in definedValues) + { + if (definedValue.Item == null) + { + continue; + } + + // Get property name which is a string representation of the first item + string name = ObjectWrapperTypeConverter.Default.ConvertFrom(definedValue.Item).ToString(); + if (name.Length == 0) + { + // Empty property name cannot be handled + // TODO: may need to generate a random property name + continue; + } + + // If the property with such name already exists, skip it and continue to + // the next defined value + if (wrapper[name] != null) + { + continue; + } + + if (stringBuilder.Length > 0) + { + stringBuilder.Append(CultureInfo.CurrentCulture.TextInfo.ListSeparator); + stringBuilder.Append(" "); + } + + if (definedValue.Items == null || definedValue.Items.Length == 0) + { + // If there is just one item, add the property now as an empty string + stringBuilder.Append(name); + wrapper[name] = String.Empty; + continue; + } + + // Convert remaining items to an wrapper object + object wrappedValue = ConvertToObjectWrapper(definedValue.Items); + + // Add string representation of the wrappedValue to the string builder + if (definedValue.Items.Length > 1) + { + // In the case of multiple items, we need parenthesis around the value string, + // which should be a comma separated list in this case. + stringBuilder.AppendFormat(CultureInfo.CurrentCulture, "[{0}] = ({1})", name, wrappedValue); + } + else + { + stringBuilder.AppendFormat(CultureInfo.CurrentCulture, "[{0}] = {1}", name, wrappedValue); + } + + wrapper[name] = wrappedValue; + } + + // Finally store the display name in the wrapper and return it. + wrapper.DisplayName = stringBuilder.ToString(); + return wrapper; + } + + /// + /// Converts ObjectType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(SetOptionsType item) + { + return ConvertToWrapperObject(item); + } + + /// + /// Converts RollupLevelType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(RollupLevelType item) + { + return new ExpandableObjectWrapper(item,SR.Level,item.Level.ToString()); + } + + /// + /// Converts WarningsType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(WarningsType item) + { + string displayName = String.Empty; + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(item); + + ProcessSpillOccurred(wrapper, ref displayName); + ProcessColumnWithNoStatistics(wrapper, ref displayName); + ProcessNoJoinPredicate(wrapper, ref displayName); + ProcessSpillToTempDb(wrapper, ref displayName); + ProcessHashSpillDetails(wrapper, ref displayName); + ProcessSortSpillDetails(wrapper, ref displayName); + ProcessWaits(wrapper, ref displayName); + ProcessPlanAffectingConvert(wrapper, ref displayName); + ProcessMemoryGrantWarning(wrapper, ref displayName); + ProcessFullUpdateForOnlineIndexBuild(wrapper, ref displayName); + + if (wrapper["FullUpdateForOnlineIndexBuild"] != null) + { + displayName = MergeString(CultureInfo.CurrentCulture.TextInfo.ListSeparator + " ", + displayName, SR.FullUpdateForOnlineIndexBuild); + } + + wrapper.DisplayName = displayName; + + return wrapper; + } + + private static void ProcessWaits(ExpandableObjectWrapper wrapper, ref string displayName) + { + if (wrapper["Wait"] != null) + { + List propList = GetPropertyList(wrapper, "Wait"); + + Dictionary waitTimePerWaitType = new Dictionary(); + + foreach (ExpandableObjectWrapper eow in propList) + { + PropertyValue pVal = eow.Properties["WaitTime"] as PropertyValue; + string waitTime = pVal.Value.ToString(); + + pVal = eow.Properties["WaitType"] as PropertyValue; + string waitType = pVal.Value.ToString(); + + if (waitTimePerWaitType.ContainsKey(waitType)) + { + waitTimePerWaitType[waitType] += int.Parse(waitTime); + } + else + { + waitTimePerWaitType.Add(waitType, int.Parse(waitTime)); + } + } + + foreach (KeyValuePair kvp in waitTimePerWaitType) + { + string displayStr = string.Format(SR.Wait, kvp.Value, kvp.Key); + + displayName = MergeString(CultureInfo.CurrentCulture.TextInfo.ListSeparator + " ", + displayName, displayStr); + } + } + } + + private static void ProcessSpillToTempDb(ExpandableObjectWrapper wrapper, ref string displayName) + { + if (wrapper["SpillToTempDb"] != null) + { + List propList = GetPropertyList(wrapper, "SpillToTempDb"); + + foreach (ExpandableObjectWrapper eow in propList) + { + PropertyValue pVal = eow.Properties["SpillLevel"] as PropertyValue; + string spillLevel = pVal.Value.ToString(); + pVal = eow.Properties["SpilledThreadCount"] as PropertyValue; + string displayStr = pVal != null ? + string.Format(CultureInfo.CurrentCulture, SR.SpillToTempDb, spillLevel, pVal.Value.ToString()) : + string.Format(CultureInfo.CurrentCulture, SR.SpillToTempDbOld, spillLevel); + + displayName = MergeString(CultureInfo.CurrentCulture.TextInfo.ListSeparator + " ", + displayName, displayStr); + } + } + + } + + private static void GetCommonSpillDetails(ExpandableObjectWrapper eow, out string grantedMemory, out string usedMemory, out string writes, out string reads) + { + PropertyValue pVal = eow.Properties["GrantedMemoryKb"] as PropertyValue; + grantedMemory = pVal.Value.ToString(); + pVal = eow.Properties["UsedMemoryKb"] as PropertyValue; + usedMemory = pVal.Value.ToString(); + pVal = eow.Properties["WritesToTempDb"] as PropertyValue; + writes = pVal.Value.ToString(); + pVal = eow.Properties["ReadsFromTempDb"] as PropertyValue; + reads = pVal.Value.ToString(); + } + + private static void ProcessHashSpillDetails(ExpandableObjectWrapper wrapper, ref string displayName) + { + if (wrapper["HashSpillDetails"] != null) + { + List propList = GetPropertyList(wrapper, "HashSpillDetails"); + + string grantedMemory; + string usedMemory; + string writes; + string reads; + foreach (ExpandableObjectWrapper eow in propList) + { + GetCommonSpillDetails(eow, out grantedMemory, out usedMemory, out writes, out reads); + + string displayStr = string.Format(SR.HashSpillDetails, writes, reads, grantedMemory, usedMemory); + + displayName = MergeString(CultureInfo.CurrentCulture.TextInfo.ListSeparator + " ", + displayName, displayStr); + } + } + + } + + private static void ProcessSortSpillDetails(ExpandableObjectWrapper wrapper, ref string displayName) + { + if (wrapper["SortSpillDetails"] != null) + { + List propList = GetPropertyList(wrapper, "SortSpillDetails"); + + string grantedMemory; + string usedMemory; + string writes; + string reads; + foreach (ExpandableObjectWrapper eow in propList) + { + GetCommonSpillDetails(eow, out grantedMemory, out usedMemory, out writes, out reads); + + string displayStr = string.Format(SR.SortSpillDetails, writes, reads, grantedMemory, usedMemory); + + displayName = MergeString(CultureInfo.CurrentCulture.TextInfo.ListSeparator + " ", + displayName, displayStr); + } + } + + } + + private static void ProcessSpillOccurred(ExpandableObjectWrapper wrapper, ref string displayName) + { + if (wrapper["SpillOccurred"] != null) + { + displayName = MergeString(CultureInfo.CurrentCulture.TextInfo.ListSeparator + " ", + displayName, SR.SpillOccurredDisplayString); + } + } + + private static void ProcessNoJoinPredicate(ExpandableObjectWrapper wrapper, ref string displayName) + { + if (Object.Equals(wrapper["NoJoinPredicate"], true)) + { + displayName = MergeString(CultureInfo.CurrentCulture.TextInfo.ListSeparator + " ", + displayName, SR.NoJoinPredicate); + } + } + + private static void ProcessColumnWithNoStatistics(ExpandableObjectWrapper wrapper, ref string displayName) + { + if (wrapper["ColumnsWithNoStatistics"] != null) + { + + ExpandableObjectWrapper eow = wrapper["ColumnsWithNoStatistics"] as ExpandableObjectWrapper; + PropertyValue pVal = eow.Properties["ColumnReference"] as PropertyValue; + string displayStr = pVal.Value.ToString(); + + displayName = SR.NameValuePair(SR.ColumnsWithNoStatistics, displayStr); + } + } + + private static void ProcessFullUpdateForOnlineIndexBuild(ExpandableObjectWrapper wrapper, ref string displayName) + { + if (wrapper["FullUpdateForOnlineIndexBuild"] != null) + { + displayName = MergeString(CultureInfo.CurrentCulture.TextInfo.ListSeparator + " ", + displayName, SR.FullUpdateForOnlineIndexBuild); + } + } + + + private static void ProcessPlanAffectingConvert(ExpandableObjectWrapper wrapper, ref string displayName) + { + if (wrapper["PlanAffectingConvert"] != null) + { + List propList = GetPropertyList(wrapper, "PlanAffectingConvert"); + + foreach (ExpandableObjectWrapper eow in propList) + { + PropertyValue pVal = eow.Properties["ConvertIssue"] as PropertyValue; + string convertIssue = pVal.Value.ToString(); + pVal = eow.Properties["Expression"] as PropertyValue; + string expression = pVal.Value.ToString(); + string displayStr = string.Format(SR.PlanAffectingConvert, expression, convertIssue); + + displayName = MergeString(CultureInfo.CurrentCulture.TextInfo.ListSeparator + " ", + displayName, displayStr); + } + } + } + + private static void ProcessMemoryGrantWarning(ExpandableObjectWrapper wrapper, ref string displayName) + { + if (wrapper["MemoryGrantWarning"] != null) + { + List propList = GetPropertyList(wrapper, "MemoryGrantWarning"); + + foreach (ExpandableObjectWrapper eow in propList) + { + PropertyValue pValKind = eow.Properties["GrantWarningKind"] as PropertyValue; + PropertyValue pValRequested = eow.Properties["RequestedMemory"] as PropertyValue; + PropertyValue pValGranted = eow.Properties["GrantedMemory"] as PropertyValue; + PropertyValue pValUsed = eow.Properties["MaxUsedMemory"] as PropertyValue; + + if (pValKind != null && pValGranted != null && pValRequested != null && pValUsed != null) + { + string displayString = string.Format(SR.MemoryGrantWarning, pValKind.Value.ToString(), + pValRequested.Value.ToString(), pValGranted.Value.ToString(), pValUsed.Value.ToString()); + + displayName = MergeString(CultureInfo.CurrentCulture.TextInfo.ListSeparator + " ", + displayName, displayString); + } + } + } + } + + private static List GetPropertyList(ExpandableObjectWrapper wrapper, string propertyName) + { + List propList = new List(); + + foreach (PropertyDescriptor pd in wrapper.Properties) + { + if (pd.Name == propertyName) + { + PropertyValue pVal = pd as PropertyValue; + propList.Add(pVal.Value as ExpandableObjectWrapper); + } + } + + return propList; + } + + /// + /// Converts WarningsType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(MemoryFractionsType item) + { + return ConvertToWrapperObject(item); + } + + /// + /// Converts ScalarType[][] to a string + /// The format looks like (1,2,3), (4,5,6) + /// + /// + /// + public static ExpandableObjectWrapper Convert(ScalarType[][] items) + { + ExpandableObjectWrapper wrapper = new ExpandableArrayWrapper(items); + string separator = CultureInfo.CurrentCulture.TextInfo.ListSeparator + " "; + StringBuilder stringBuilder = new StringBuilder(); + + for (int i = 0; i < items.Length; i++) + { + if (i != 0) + { + stringBuilder.Append(separator); + } + + stringBuilder.Append("("); + + for (int j = 0; j < items[i].Length; j++ ) + { + if (j != 0) + { + stringBuilder.Append(separator); + } + stringBuilder.Append(Convert(items[i][j])); + } + + stringBuilder.Append(")"); + } + + wrapper.DisplayName = stringBuilder.ToString(); + return wrapper; + } + + /// + /// Converts ScalarType to a wrapper object + /// + /// scalar to be converted + /// + public static ExpandableObjectWrapper Convert(ScalarType item) + { + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(item); + if (!string.IsNullOrEmpty(item.ScalarString)) // optional attribute + { + wrapper.DisplayName = String.Format( + CultureInfo.CurrentCulture, "{0}({1})", SR.ScalarOperator, item.ScalarString); + } + else + { + wrapper.DisplayName = SR.ScalarOperator; + } + return wrapper; + } + + /// + /// Converts ScalarType to a string. + /// + /// Object to convert. + /// Scalar string. + public static string Convert(ScalarExpressionType item) + { + return item.ScalarOperator != null ? item.ScalarOperator.ScalarString : String.Empty; + } + + /// + /// Converts CompareType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(CompareType item) + { + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(item); + + object scalarOperator = wrapper["ScalarOperator"]; + if (scalarOperator != null) + { + wrapper.DisplayName = item.CompareOp.ToString(); + } + else + { + wrapper.DisplayName = String.Format( + CultureInfo.CurrentCulture, "{0}({1})", item.CompareOp, scalarOperator); + } + + return wrapper; + } + + /// + /// Converts OrderByTypeOrderByColumn to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(OrderByTypeOrderByColumn item) + { + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(item); + wrapper.DisplayName = String.Format( + CultureInfo.CurrentCulture, + "{0} {1}", + wrapper["ColumnReference"], + item.Ascending ? SR.Ascending : SR.Descending); + return wrapper; + } + + /// + /// Converts ScanRangeType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(ScanRangeType item) + { + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(item); + + object rangeColumn = wrapper["RangeColumns"]; + object rangeExpressions = wrapper["RangeExpressions"]; + + if (rangeColumn != null && rangeExpressions != null) + { + string compareOperator = String.Empty; + switch (item.ScanType) + { + case CompareOpType.EQ: + compareOperator = "="; + break; + case CompareOpType.GE: + compareOperator = ">="; + break; + case CompareOpType.GT: + compareOperator = ">"; + break; + case CompareOpType.LE: + compareOperator = "<="; + break; + case CompareOpType.LT: + compareOperator = "<"; + break; + case CompareOpType.NE: + compareOperator = "<>"; + break; + } + + if (compareOperator.Length > 0) + { + wrapper.DisplayName = String.Format( + CultureInfo.CurrentCulture, + "{0} {1} {2}", + rangeColumn, + compareOperator, + rangeExpressions); + } + else + { + wrapper.DisplayName = String.Format( + CultureInfo.CurrentCulture, + "{0}({1})", + item.ScanType, + MergeString(",", rangeColumn, rangeExpressions)); + } + } + + return wrapper; + } + + /// + /// Converts SeekPredicateType to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(SeekPredicateType item) + { + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(item); + // Make display name from names and values of the following 3 properties + wrapper.DisplayName = MakeDisplayNameFromObjectNamesAndValues(wrapper, + "Prefix", "StartRange", "EndRange"); + + return wrapper; + } + + + /// + /// Converts SeekPredicatesType to a wrapper object. + /// + /// Objects to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(SeekPredicatesType item) + { + ExpandableObjectWrapper wrapper = null; + if (item.Items.Length > 0 && item.Items[0] is SeekPredicateNewType) + { + // New schema. Parse it differently. + + wrapper = new ExpandableArrayWrapper(item.Items); + string separator = CultureInfo.CurrentCulture.TextInfo.ListSeparator + " "; + + PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(wrapper); + if (properties.Count > 1) + { + // If there are more than one SeekPredicateNew, merge the tooltips + StringBuilder stringBuilder = new StringBuilder(); + for (int i = 0; i < properties.Count; i++) + { + if (i != 0) + { + stringBuilder.Append(separator); + } + stringBuilder.Append(String.Format( + CultureInfo.CurrentCulture, + "{0} {1}", + properties[i].DisplayName, + properties[i].GetValue(wrapper).ToString())); + } + wrapper.DisplayName = stringBuilder.ToString(); + } + } + else + { + wrapper = new ExpandableArrayWrapper(item.Items); + } + return wrapper; + } + + /// + /// Converts SeekPredicateNewType to a wrapper object. + /// + /// Objects to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(SeekPredicateNewType item) + { + ExpandableObjectWrapper wrapper = new ExpandableArrayWrapper(item.SeekKeys); + + // Add string "SeekKeys" to the tooltip + string separator = CultureInfo.CurrentCulture.TextInfo.ListSeparator + " "; + StringBuilder stringBuilder = new StringBuilder(); + + PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(wrapper); + for (int i = 0; i < properties.Count; i++) + { + if (i != 0) + { + stringBuilder.Append(separator); + } + stringBuilder.Append(String.Format( + CultureInfo.CurrentCulture, + "{0}[{1}]: {2}", + SR.SeekKeys, + i+1, + properties[i].GetValue(wrapper).ToString())); + } + + wrapper.DisplayName = stringBuilder.ToString(); + return wrapper; + } + + /// + /// Converts SeekPredicatePartType to a wrapper object. + /// + /// Objects to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(SeekPredicatePartType item) + { + ExpandableObjectWrapper wrapper = new ExpandableArrayWrapper(item.Items); + string separator = CultureInfo.CurrentCulture.TextInfo.ListSeparator + " "; + + PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(wrapper); + if (properties.Count > 1) + { + // If there are more than one SeekPredicateNew, merge the tooltips + StringBuilder stringBuilder = new StringBuilder(); + for (int i = 0; i < properties.Count; i++) + { + if (i != 0) + { + stringBuilder.Append(separator); + } + stringBuilder.Append(String.Format( + CultureInfo.CurrentCulture, + "{0} {1}", + properties[i].DisplayName, + properties[i].GetValue(wrapper).ToString())); + } + wrapper.DisplayName = stringBuilder.ToString(); + } + return wrapper; + } + + /// + /// Converts MergeColumns to a wrapper object. + /// + /// Object to convert. + /// Wrapper object. + public static ExpandableObjectWrapper Convert(MergeColumns item) + { + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(item); + + object innerSideJoinColumns = wrapper["InnerSideJoinColumns"]; + object outerSideJoinColumns = wrapper["OuterSideJoinColumns"]; + + if (innerSideJoinColumns != null && outerSideJoinColumns != null) + { + wrapper.DisplayName = String.Format( + CultureInfo.CurrentCulture, + "({0}) = ({1})", + innerSideJoinColumns, + outerSideJoinColumns); + } + + return wrapper; + } + + public static string Convert(BaseStmtInfoTypeStatementOptmEarlyAbortReason item) + { + switch (item) + { + case BaseStmtInfoTypeStatementOptmEarlyAbortReason.TimeOut: + return SR.TimeOut; + + case BaseStmtInfoTypeStatementOptmEarlyAbortReason.MemoryLimitExceeded: + return SR.MemoryLimitExceeded; + + case BaseStmtInfoTypeStatementOptmEarlyAbortReason.GoodEnoughPlanFound: + return SR.GoodEnoughPlanFound; + + default: + return item.ToString(); + } + } + + public static string Convert(CloneAccessScopeType item) + { + switch (item) + { + case CloneAccessScopeType.Primary: + return SR.PrimaryClones; + + case CloneAccessScopeType.Secondary: + return SR.SecondaryClones; + + case CloneAccessScopeType.Both: + return SR.BothClones; + + case CloneAccessScopeType.Either: + return SR.EitherClones; + + case CloneAccessScopeType.ExactMatch: + return SR.ExactMatchClones; + + default: + return item.ToString(); + } + } + + #endregion + + #region Converters for types to be ignored + + public static object Convert(InternalInfoType item) + { + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(); + StringBuilder stringBuilder = new StringBuilder(); + + using (XmlTextWriter writer = new XmlTextWriter(new StringWriter(stringBuilder, CultureInfo.InvariantCulture))) + { + writer.WriteStartElement("InternalInfo"); + + if (item.AnyAttr != null) + { + foreach (XmlAttribute attribute in item.AnyAttr) + { + object value = ObjectWrapperTypeConverter.Convert(attribute); + if (value != null) + { + wrapper[attribute.Name] = value; + writer.WriteAttributeString(XmlConvert.EncodeLocalName(attribute.Name), value.ToString()); + } + } + } + + if (item.Any != null) + { + foreach (XmlElement node in item.Any) + { + object value = ObjectWrapperTypeConverter.Convert(node); + if (value != null) + { + wrapper[node.Name] = value; + writer.WriteRaw(Convert(node).ToString()); + } + } + } + + writer.WriteEndElement(); + } + + wrapper.DisplayName = stringBuilder.ToString(); + return wrapper; + } + + public static object Convert(System.Xml.XmlElement item) + { + ExpandableObjectWrapper wrapper = new ExpandableObjectWrapper(); + + StringBuilder stringBuilder = new StringBuilder(); + + using (XmlTextWriter writer = new XmlTextWriter(new StringWriter(stringBuilder, CultureInfo.InvariantCulture))) + { + writer.WriteStartElement(XmlConvert.EncodeLocalName(item.Name)); + + foreach (XmlAttribute attribute in item.Attributes) + { + object value = ObjectWrapperTypeConverter.Convert(attribute); + if (value != null) + { + wrapper[attribute.Name] = value; + writer.WriteAttributeString(XmlConvert.EncodeLocalName(attribute.Name), value.ToString()); + } + } + + foreach (XmlElement node in item.ChildNodes) + { + object value = ObjectWrapperTypeConverter.Convert(node); + if (value != null) + { + wrapper[node.Name] = value; + writer.WriteRaw(Convert(node).ToString()); + } + } + + writer.WriteEndElement(); + } + + wrapper.DisplayName = stringBuilder.ToString(); + return wrapper; + } + + public static object Convert(System.Xml.XmlAttribute item) + { + return item.Value; + } + + #endregion + + #region TypeConverter overrides + + /// + /// Determines if this converter can convert an object from the specified type. + /// + /// Type descriptor context. + /// Source object type. + /// True if the object can be converted; otherwise false. + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + return Type.GetTypeCode(sourceType) == TypeCode.Object || sourceType.IsArray || convertMethods.ContainsKey(sourceType); + } + + /// + /// Converts an object to a type supported by this converter. + /// Note that the target type is determined by the converter itself. + /// + /// Type descriptor context. + /// Culture. + /// The object or value to convert from. + /// The converted object. + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + MethodInfo converter; + if (convertMethods.TryGetValue(value.GetType(), out converter)) + { + return converter.Invoke( + null, + BindingFlags.Public | BindingFlags.Static, + null, + new object[]{ value }, + CultureInfo.CurrentCulture); + } + else + { + // TODO: review this - may need better condition + return ConvertToObjectWrapper(value); + } + } + + /// + /// Converts an object to a specified type. + /// + /// Type descriptor context. + /// Culture. + /// The object or value to convert from. + /// Target type to convert to. + /// The converted object. + public override object ConvertTo(ITypeDescriptorContext context, + System.Globalization.CultureInfo culture, + object value, Type destType) + { + MethodInfo converter; + if (convertMethods.TryGetValue(value.GetType(), out converter) && converter.ReturnType == destType) + { + return converter.Invoke(this, new object[] { value }); + } + else + { + // TODO: review this - may need better condition + return ConvertToObjectWrapper(value); + } + } + + #endregion + + #region Implementation details + + /// + /// Converts an object to a wrapper object. + /// + /// An object to convert. + /// Array or object wrapper that implements ICustomTypeDescriptor and provides expandable properties. + private static object ConvertToObjectWrapper(object item) + { + ICollection collection = item as ICollection; + if (collection != null) + { + if (collection.Count == 1) + { + // There is only one object in the collection + // so return the first item. + IEnumerator enumerator = collection.GetEnumerator(); + enumerator.MoveNext(); + return ObjectWrapperTypeConverter.Default.ConvertFrom(enumerator.Current); + } + else + { + return new ExpandableArrayWrapper(collection); + } + } + else + { + // Non-collection case. + return new ExpandableObjectWrapper(item); + } + } + + /// + /// Static constructor + /// + static ObjectWrapperTypeConverter() + { + // Hash all Convert methods by their argument type + foreach (MethodInfo methodInfo in typeof(ObjectWrapperTypeConverter).GetMethods(BindingFlags.Public | BindingFlags.Static)) + { + if (methodInfo.Name == "Convert") + { + ParameterInfo[] parameters = methodInfo.GetParameters(); + if (parameters.Length == 1) + { + convertMethods.Add(parameters[0].ParameterType, methodInfo); + } + } + } + } + + /// + /// Constructs string from multiple items. + /// + /// Separator placed between items. + /// Items to be merged. + /// Text string that contains merged items with separators between them. + internal static string MergeString(string separator, params object[] items) + { + StringBuilder builder = new StringBuilder(); + + foreach (object item in items) + { + if (item != null) + { + string itemText = item.ToString(); + + if (itemText.Length > 0) + { + if (builder.Length > 0) + { + builder.Append(separator); + } + + builder.Append(itemText); + } + } + } + + return builder.ToString(); + } + + /// + /// Makes a comma separated list from object property names and values. + /// This method overload enumerates all properties. + /// + /// Object to get display name for. + /// Display name string. + private static string MakeDisplayNameFromObjectNamesAndValues(object item) + { + StringBuilder stringBuilder = new StringBuilder(); + + foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(item)) + { + AppendPropertyNameValuePair(stringBuilder, item, property); + } + + return stringBuilder.ToString(); + } + + /// + /// Makes a comma separated list from object property names and values. + /// This method overload uses only specified properties. + /// + /// Object to get display name for. + /// + private static string MakeDisplayNameFromObjectNamesAndValues(object item, params string[] propertyNames) + { + StringBuilder stringBuilder = new StringBuilder(); + PropertyDescriptorCollection allProperties = TypeDescriptor.GetProperties(item); + foreach (string name in propertyNames) + { + PropertyDescriptor property = allProperties[name]; + if (property != null) + { + AppendPropertyNameValuePair(stringBuilder, item, property); + } + } + + return stringBuilder.ToString(); + } + + /// + /// An utility method that appends property name and value to string builder. + /// + /// String builder. + /// Object that contains properties. + /// Property Descriptor. + private static void AppendPropertyNameValuePair(StringBuilder stringBuilder, object item, PropertyDescriptor property) + { + object propertyValue = property.GetValue(item); + if (propertyValue != null) + { + if (stringBuilder.Length > 0) + { + stringBuilder.Append(CultureInfo.CurrentCulture.TextInfo.ListSeparator); + stringBuilder.Append(" "); + } + + stringBuilder.Append(SR.NameValuePair(property.DisplayName, propertyValue.ToString())); + } + } + + private static Dictionary convertMethods = new Dictionary(); + + #endregion + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Operation.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Operation.cs new file mode 100644 index 00000000..74ac3fd7 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/Operation.cs @@ -0,0 +1,132 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Diagnostics; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + public sealed class Operation + { + + + /// + /// Constructs Operation. + /// + /// Operator name + /// Display name resource ID + /// Description resource ID + /// Image name + public Operation(string name, string displayNameKey, string descriptionKey, string imageName) + { + this.name = name; + this.displayNameKey = displayNameKey; + this.descriptionKey = descriptionKey; + this.imageName = imageName; + } + + /// + /// + /// + /// Operator name + /// Display name resource ID + /// + public Operation(string name, string displayNameKey): this(name, displayNameKey, null, null) + { + + } + + /// + /// Gets operator name. + /// + public string Name + { + get { return this.name; } + } + + /// + /// Gets localized display name. + /// + public string DisplayName + { + get + { + if (this.displayName == null && this.displayNameKey != null) + { + this.displayName = SR.Keys.GetString(this.displayNameKey); + Debug.Assert(this.displayName != null); + } + + return this.displayName != null ? this.displayName : this.name; + } + } + + /// + /// Gets localized description. + /// + public string Description + { + get + { + if (this.description == null && this.descriptionKey != null) + { + this.description = SR.Keys.GetString(this.descriptionKey); + Debug.Assert(this.description != null); + } + + return this.description; + } + } + + /// + /// Gets image. + /// + public string Image + { + get + { + if (this.image == null && this.imageName != null) + { + this.image = this.imageName; + } + return this.image; + } + } + + /// + /// Creates one-off operation with only display name. + /// + /// Operation display name. + public static Operation CreateUnknown(string operationDisplayName, string iconName) + { + return new Operation(operationDisplayName, null, null, iconName); + } + + /// + /// Unknown operation + /// + public static Operation Unknown + { + get { return Operation.unknown; } + } + + private string name; + private string displayNameKey; + private string descriptionKey; + private string imageName; + private string helpKeyword; + private Type displayNodeType; + + private string image; + private string displayName; + private string description; + + private static readonly Operation unknown = new Operation( + String.Empty, + SR.Keys.Unknown, + SR.Keys.UnknownDescription, + "Result_32x.ico"); + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/OperationTable.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/OperationTable.cs new file mode 100644 index 00000000..fccb91e0 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/OperationTable.cs @@ -0,0 +1,400 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// A class that holds information about a physical or logical operator, or a statement. + /// + internal static class OperationTable + { + #region Public members + + public static Operation GetStatement(string statementTypeName) + { + Operation operation; + + if (!Statements.TryGetValue(statementTypeName, out operation)) + { + operation = Operation.CreateUnknown(statementTypeName, "Language_construct_catch_all.ico"); + } + + return operation; + } + + public static Operation GetCursorType(string cursorTypeName) + { + Operation operation; + + if (!CursorTypes.TryGetValue(cursorTypeName, out operation)) + { + cursorTypeName = GetNameFromXmlEnumAttribute(cursorTypeName, typeof(CursorType)); + operation = Operation.CreateUnknown(cursorTypeName, "Cursor_catch_all_32x.ico"); + } + + return operation; + } + + public static Operation GetPhysicalOperation(string operationType) + { + Operation operation; + + if (!PhysicalOperations.TryGetValue(operationType, out operation)) + { + operationType = GetNameFromXmlEnumAttribute(operationType, typeof(PhysicalOpType)); + operation = Operation.CreateUnknown(operationType, "Iterator_catch_all.ico"); + } + + return operation; + } + + public static Operation GetLogicalOperation(string operationType) + { + Operation operation; + + if (!LogicalOperations.TryGetValue(operationType, out operation)) + { + operationType = GetNameFromXmlEnumAttribute(operationType, typeof(LogicalOpType)); + // Should not use Operation.CreateUnknown here, because it would + // use some default description and icons. Instead we should fall back to description + // and Icon from the corresponding physical operation. + operation = new Operation(null, operationType); + } + + return operation; + } + + public static Operation GetUdf() + { + return new Operation(null, SR.Keys.Udf, null, "Language_construct_catch_all.ico"); + } + + public static Operation GetStoredProc() + { + return new Operation(null, SR.Keys.StoredProc, null, "Language_construct_catch_all.ico"); + } + + #endregion + + #region Implementation details + + static OperationTable() + { + Operation[] physicalOperationList = new Operation[] + { + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// XML ShowPlan Operators (see showplanxml.cs for the list) + /// Name / Type SR Display Name Key SR Description Key Image + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + new Operation("AdaptiveJoin", SR.Keys.AdaptiveJoin, SR.Keys.AdaptiveJoinDescription, "Adaptive_Join_32x.ico"), + new Operation("Assert", SR.Keys.Assert, SR.Keys.AssertDescription, "Assert_32x.ico"), + new Operation("Bitmap", SR.Keys.Bitmap, SR.Keys.BitmapDescription, "Bitmap_32x.ico"), + new Operation("ClusteredIndexDelete", SR.Keys.ClusteredIndexDelete, SR.Keys.ClusteredIndexDeleteDescription, "Clustered_index_delete_32x.ico"), + new Operation("ClusteredIndexInsert", SR.Keys.ClusteredIndexInsert, SR.Keys.ClusteredIndexInsertDescription, "Clustered_index_insert_32x.ico"), + new Operation("ClusteredIndexScan", SR.Keys.ClusteredIndexScan, SR.Keys.ClusteredIndexScanDescription, "Clustered_index_scan_32x.ico"), + new Operation("ClusteredIndexSeek", SR.Keys.ClusteredIndexSeek, SR.Keys.ClusteredIndexSeekDescription, "Clustered_index_seek_32x.ico"), + new Operation("ClusteredIndexUpdate", SR.Keys.ClusteredIndexUpdate, SR.Keys.ClusteredIndexUpdateDescription, "Clustered_index_update_32x.ico"), + new Operation("ClusteredIndexMerge", SR.Keys.ClusteredIndexMerge, SR.Keys.ClusteredIndexMergeDescription, "Clustered_index_merge_32x.ico"), + new Operation("ClusteredUpdate", SR.Keys.ClusteredUpdate, SR.Keys.ClusteredUpdateDescription, "Clustered_update_32x.ico"), + new Operation("Collapse", SR.Keys.Collapse, SR.Keys.CollapseDescription, "Collapse_32x.ico"), + new Operation("ComputeScalar", SR.Keys.ComputeScalar, SR.Keys.ComputeScalarDescription, "Compute_scalar_32x.ico"), + new Operation("Concatenation", SR.Keys.Concatenation, SR.Keys.ConcatenationDescription, "Concatenation_32x.ico"), + new Operation("ConstantScan", SR.Keys.ConstantScan, SR.Keys.ConstantScanDescription, "Constant_scan_32x.ico"), + new Operation("DeletedScan", SR.Keys.DeletedScan, SR.Keys.DeletedScanDescription, "Deleted_scan_32x.ico"), + new Operation("Filter", SR.Keys.Filter, SR.Keys.FilterDescription, "Filter_32x.ico"), + new Operation("HashMatch", SR.Keys.HashMatch, SR.Keys.HashMatchDescription, "Hash_match_32x.ico"), + new Operation("IndexDelete", SR.Keys.IndexDelete, SR.Keys.IndexDeleteDescription, "Nonclust_index_delete_32x.ico"), + new Operation("IndexInsert", SR.Keys.IndexInsert, SR.Keys.IndexInsertDescription, "Nonclust_index_insert_32x.ico"), + new Operation("IndexScan", SR.Keys.IndexScan, SR.Keys.IndexScanDescription, "Nonclust_index_scan_32x.ico"), + new Operation("ColumnstoreIndexDelete", SR.Keys.ColumnstoreIndexDelete, SR.Keys.ColumnstoreIndexDeleteDescription, "Columnstore_index_delete_32x.ico"), + new Operation("ColumnstoreIndexInsert", SR.Keys.ColumnstoreIndexInsert, SR.Keys.ColumnstoreIndexInsertDescription, "Columnstore_index_insert_32x.ico"), + new Operation("ColumnstoreIndexMerge", SR.Keys.ColumnstoreIndexMerge, SR.Keys.ColumnstoreIndexMergeDescription, "Columnstore_index_merge_32x.ico"), + new Operation("ColumnstoreIndexScan", SR.Keys.ColumnstoreIndexScan, SR.Keys.ColumnstoreIndexScanDescription, "Columnstore_index_scan_32x.ico"), + new Operation("ColumnstoreIndexUpdate", SR.Keys.ColumnstoreIndexUpdate, SR.Keys.ColumnstoreIndexUpdateDescription, "Columnstore_index_update_32x.ico"), + new Operation("IndexSeek", SR.Keys.IndexSeek, SR.Keys.IndexSeekDescription, "Nonclust_index_seek_32x.ico"), + new Operation("IndexSpool", SR.Keys.IndexSpool, SR.Keys.IndexSpoolDescription, "Nonclust_index_spool_32x.ico"), + new Operation("IndexUpdate", SR.Keys.IndexUpdate, SR.Keys.IndexUpdateDescription, "Nonclust_index_update_32x.ico"), + new Operation("InsertedScan", SR.Keys.InsertedScan, SR.Keys.InsertedScanDescription, "Inserted_scan_32x.ico"), + new Operation("LogRowScan", SR.Keys.LogRowScan, SR.Keys.LogRowScanDescription, "Log_row_scan_32x.ico"), + new Operation("MergeInterval", SR.Keys.MergeInterval, SR.Keys.MergeIntervalDescription, "Merge_interval_32x.ico"), + new Operation("MergeJoin", SR.Keys.MergeJoin, SR.Keys.MergeJoinDescription, "Merge_join_32x.ico"), + new Operation("NestedLoops", SR.Keys.NestedLoops, SR.Keys.NestedLoopsDescription, "Nested_loops_32x.ico"), + new Operation("Parallelism", SR.Keys.Parallelism, SR.Keys.ParallelismDescription, "Parallelism_32x.ico"), + new Operation("ParameterTableScan", SR.Keys.ParameterTableScan, SR.Keys.ParameterTableScanDescription, "Parameter_table_scan_32x.ico"), + new Operation("Print", SR.Keys.Print, SR.Keys.PrintDescription, "Print.ico"), + new Operation("Put", SR.Keys.Put, SR.Keys.PutDescription, "Put_32x.ico"), + new Operation("Rank", SR.Keys.Rank, SR.Keys.RankDescription, "Rank_32x.ico"), + // using the temporary icon as of now. Once the new icon is available, it will be updated. + new Operation("ForeignKeyReferencesCheck", SR.Keys.ForeignKeyReferencesCheck, SR.Keys.ForeignKeyReferencesCheckDescription, "Referential_Integrity_32x.ico"), + new Operation("RemoteDelete", SR.Keys.RemoteDelete, SR.Keys.RemoteDeleteDescription, "Remote_delete_32x.ico"), + new Operation("RemoteIndexScan", SR.Keys.RemoteIndexScan, SR.Keys.RemoteIndexScanDescription, "Remote_index_scan_32x.ico"), + new Operation("RemoteIndexSeek", SR.Keys.RemoteIndexSeek, SR.Keys.RemoteIndexSeekDescription, "Remote_index_seek_32x.ico"), + new Operation("RemoteInsert", SR.Keys.RemoteInsert, SR.Keys.RemoteInsertDescription, "Remote_insert_32x.ico"), + new Operation("RemoteQuery", SR.Keys.RemoteQuery, SR.Keys.RemoteQueryDescription, "Remote_query_32x.ico"), + new Operation("RemoteScan", SR.Keys.RemoteScan, SR.Keys.RemoteScanDescription, "Remote_scan_32x.ico"), + new Operation("RemoteUpdate", SR.Keys.RemoteUpdate, SR.Keys.RemoteUpdateDescription, "Remote_update_32x.ico"), + new Operation("RIDLookup", SR.Keys.RIDLookup, SR.Keys.RIDLookupDescription, "RID_clustered_locate_32x.ico"), + new Operation("RowCountSpool", SR.Keys.RowCountSpool, SR.Keys.RowCountSpoolDescription, "Remote_count_spool_32x.ico"), + new Operation("Segment", SR.Keys.Segment, SR.Keys.SegmentDescription, "Segment_32x.ico"), + new Operation("Sequence", SR.Keys.Sequence, SR.Keys.SequenceDescription, "Sequence_32x.ico"), + new Operation("SequenceProject", SR.Keys.SequenceProject, SR.Keys.SequenceProjectDescription, "Sequence_project_32x.ico"), + new Operation("Sort", SR.Keys.Sort, SR.Keys.SortDescription, "Sort_32x.ico"), + new Operation("Split", SR.Keys.Split, SR.Keys.SplitDescription, "Split_32x.ico"), + new Operation("StreamAggregate", SR.Keys.StreamAggregate, SR.Keys.StreamAggregateDescription, "Stream_aggregate_32x.ico"), + new Operation("Switch", SR.Keys.Switch, SR.Keys.SwitchDescription, "Switch_32x.ico"), + new Operation("Tablevaluedfunction", SR.Keys.TableValueFunction, SR.Keys.TableValueFunctionDescription, "Table_value_function_32x.ico"), + new Operation("TableDelete", SR.Keys.TableDelete, SR.Keys.TableDeleteDescription, "Table_delete_32x.ico"), + new Operation("TableInsert", SR.Keys.TableInsert, SR.Keys.TableInsertDescription, "Table_insert_32x.ico"), + new Operation("TableScan", SR.Keys.TableScan, SR.Keys.TableScanDescription, "Table_scan_32x.ico"), + new Operation("TableSpool", SR.Keys.TableSpool, SR.Keys.TableSpoolDescription, "Table_spool_32x.ico"), + new Operation("TableUpdate", SR.Keys.TableUpdate, SR.Keys.TableUpdateDescription, "Table_update_32x.ico"), + new Operation("TableMerge", SR.Keys.TableMerge, SR.Keys.TableMergeDescription, "Table_merge_32x.ico"), + new Operation("TFP", SR.Keys.TFP, SR.Keys.TFPDescription, "Predict_32x.ico"), + new Operation("Top", SR.Keys.Top, SR.Keys.TopDescription, "Top_32x.ico"), + new Operation("UDX", SR.Keys.UDX, SR.Keys.UDXDescription, "UDX_32x.ico"), + new Operation("BatchHashTableBuild", SR.Keys.BatchHashTableBuild, SR.Keys.BatchHashTableBuildDescription, "BatchHashTableBuild_32x.ico"), + new Operation("WindowSpool", SR.Keys.Window, SR.Keys.WindowDescription, "Table_spool_32x.ico"), + new Operation("WindowAggregate", SR.Keys.WindowAggregate, SR.Keys.WindowAggregateDescription, "Window_aggregate_32x.ico"), + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// XML ShowPlan Cursor Operators (see showplanxml.cs for the list) + /// Name / Type SR Display Name Key SR Description Key Image + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + new Operation("FetchQuery", SR.Keys.FetchQuery, SR.Keys.FetchQueryDescription, "Fetch_query_32x.ico"), + new Operation("PopulateQuery", SR.Keys.PopulationQuery, SR.Keys.PopulationQueryDescription, "Population_query_32x.ico"), + new Operation("RefreshQuery", SR.Keys.RefreshQuery, SR.Keys.RefreshQueryDescription, "Refresh_query_32x.ico"), + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Shiloh Operators (see star\sqlquery\src\plan.cpp for the list) + /// Name / Type SR Display Name Key SR Description Key Image + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + new Operation("Result", SR.Keys.Result, SR.Keys.ResultDescription, "Result_32x.ico"), + new Operation("Aggregate", SR.Keys.Aggregate, SR.Keys.AggregateDescription, "Aggregate_32x.ico"), + new Operation("Assign", SR.Keys.Assign, SR.Keys.AssignDescription, "Assign_32x.ico"), + new Operation("ArithmeticExpression", SR.Keys.ArithmeticExpression, SR.Keys.ArithmeticExpressionDescription, "Arithmetic_expression_32x.ico"), + new Operation("BookmarkLookup", SR.Keys.BookmarkLookup, SR.Keys.BookmarkLookupDescription, "Bookmark_lookup_32x.ico"), + new Operation("Convert", SR.Keys.Convert, SR.Keys.ConvertDescription, "Convert_32x.ico"), + new Operation("Declare", SR.Keys.Declare, SR.Keys.DeclareDescription, "Declare_32x.ico"), + new Operation("Delete", SR.Keys.Delete, SR.Keys.DeleteDescription, "Delete_32x.ico"), + new Operation("Dynamic", SR.Keys.Dynamic, SR.Keys.DynamicDescription, "Dynamic_32x.ico"), + new Operation("HashMatchRoot", SR.Keys.HashMatchRoot, SR.Keys.HashMatchRootDescription, "Hash_match_root_32x.ico"), + new Operation("HashMatchTeam", SR.Keys.HashMatchTeam, SR.Keys.HashMatchTeamDescription, "Hash_match_team_32x.ico"), + new Operation("If", SR.Keys.If, SR.Keys.IfDescription, "If_32x.ico"), + new Operation("Insert", SR.Keys.Insert, SR.Keys.InsertDescription, "Insert_32x.ico"), + new Operation("Intrinsic", SR.Keys.Intrinsic, SR.Keys.IntrinsicDescription, "Intrinsic_32x.ico"), + new Operation("Keyset", SR.Keys.Keyset, SR.Keys.KeysetDescription, "Keyset_32x.ico"), + new Operation("Locate", SR.Keys.Locate, SR.Keys.LocateDescription, "RID_nonclustered_locate_32x.ico"), + new Operation("PopulationQuery", SR.Keys.PopulationQuery, SR.Keys.PopulationQueryDescription, "Population_query_32x.ico"), + new Operation("SetFunction", SR.Keys.SetFunction, SR.Keys.SetFunctionDescription, "Set_function_32x.ico"), + new Operation("Snapshot", SR.Keys.Snapshot, SR.Keys.SnapshotDescription, "Snapshot_32x.ico"), + new Operation("Spool", SR.Keys.Spool, SR.Keys.SpoolDescription, "Spool_32x.ico"), + new Operation("TSQL", SR.Keys.SQL, SR.Keys.SQLDescription, "SQL_32x.ico"), + new Operation("Update", SR.Keys.Update, SR.Keys.UpdateDescription, "Update_32x.ico"), + + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Fake Operators - Used to special case existing operators and expose them using different name / icons (see sqlbu#434739) + /// Name / Type SR Display Name Key SR Description Key Image + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + new Operation("KeyLookup", SR.Keys.KeyLookup, SR.Keys.KeyLookupDescription, "Bookmark_lookup_32x.ico"), + + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// PDW Operators (See PDW comment tags in showplanxml.xsd) + /// Name / Type SR Display Name Key SR Description Key Image + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + new Operation("Apply", SR.Keys.Apply, SR.Keys.ApplyDescription, "Apply_32x.ico"), + new Operation("Broadcast", SR.Keys.Broadcast, SR.Keys.BroadcastDescription, "Broadcast_32x.ico"), + new Operation("ComputeToControlNode", SR.Keys.ComputeToControlNode, SR.Keys.ComputeToControlNodeDescription, "Compute_to_control_32x.ico"), + new Operation("ConstTableGet", SR.Keys.ConstTableGet, SR.Keys.ConstTableGetDescription, "Const_table_get_32x.ico"), + new Operation("ControlToComputeNodes", SR.Keys.ControlToComputeNodes, SR.Keys.ControlToComputeNodesDescription, "Control_to_compute_32x.ico"), + new Operation("ExternalBroadcast", SR.Keys.ExternalBroadcast, SR.Keys.ExternalBroadcastDescription, "External_broadcast_32x.ico"), + new Operation("ExternalExport", SR.Keys.ExternalExport, SR.Keys.ExternalExportDescription, "External_export_32x.ico"), + new Operation("ExternalLocalStreaming", SR.Keys.ExternalLocalStreaming, SR.Keys.ExternalLocalStreamingDescription, "External_local_streaming_32x.ico"), + new Operation("ExternalRoundRobin", SR.Keys.ExternalRoundRobin, SR.Keys.ExternalRoundRobinDescription, "External_round_robin_32x.ico"), + new Operation("ExternalShuffle", SR.Keys.ExternalShuffle, SR.Keys.ExternalShuffleDescription, "External_shuffle_32x.ico"), + new Operation("Get", SR.Keys.Get, SR.Keys.GetDescription, "Get_32x.ico"), + new Operation("GbApply", SR.Keys.GbApply, SR.Keys.GbApplyDescription, "Apply_32x.ico"), + new Operation("GbAgg", SR.Keys.GbAgg, SR.Keys.GbAggDescription, "Group_by_aggregate_32x.ico"), + new Operation("Join", SR.Keys.Join, SR.Keys.JoinDescription, "Join_32x.ico"), + new Operation("LocalCube", SR.Keys.LocalCube, SR.Keys.LocalCubeDescription, "Intrinsic_32x.ico"), + new Operation("Project", SR.Keys.Project, SR.Keys.ProjectDescription, "Project_32x.ico"), + new Operation("Shuffle", SR.Keys.Shuffle, SR.Keys.ShuffleDescription, "Shuffle_32x.ico"), + new Operation("SingleSourceRoundRobin", SR.Keys.SingleSourceRoundRobin, SR.Keys.SingleSourceRoundRobinDescription, "Single_source_round_robin_32x.ico"), + new Operation("SingleSourceShuffle", SR.Keys.SingleSourceShuffle, SR.Keys.SingleSourceShuffleDescription, "Single_source_shuffle_32x.ico"), + new Operation("Trim", SR.Keys.Trim, SR.Keys.TrimDescription, "Trim_32x.ico"), + new Operation("Union", SR.Keys.Union, SR.Keys.UnionDescription, "Union_32x.ico"), + new Operation("UnionAll", SR.Keys.UnionAll, SR.Keys.UnionAllDescription, "Union_all_32x.ico"), + }; + + PhysicalOperations = DictionaryFromList(physicalOperationList); + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Logical Operations + /// Name / Type SR Display Name Key SR Description Key Image + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + Operation[] logicalOperationList = new Operation[] + { + new Operation("Aggregate", SR.Keys.LogicalOpAggregate), + new Operation("AntiDiff", SR.Keys.LogicalOpAntiDiff), + new Operation("Assert", SR.Keys.LogicalOpAssert), + new Operation("BitmapCreate", SR.Keys.LogicalOpBitmapCreate), + new Operation("ClusteredIndexScan", SR.Keys.LogicalOpClusteredIndexScan), + new Operation("ClusteredIndexSeek", SR.Keys.LogicalOpClusteredIndexSeek), + new Operation("ClusteredUpdate", SR.Keys.LogicalOpClusteredUpdate), + new Operation("Collapse", SR.Keys.LogicalOpCollapse), + new Operation("ComputeScalar", SR.Keys.LogicalOpComputeScalar), + new Operation("Concatenation", SR.Keys.LogicalOpConcatenation), + new Operation("ConstantScan", SR.Keys.LogicalOpConstantScan), + new Operation("CrossJoin", SR.Keys.LogicalOpCrossJoin), + new Operation("Delete", SR.Keys.LogicalOpDelete), + new Operation("DeletedScan", SR.Keys.LogicalOpDeletedScan), + new Operation("DistinctSort", SR.Keys.LogicalOpDistinctSort), + new Operation("Distinct", SR.Keys.LogicalOpDistinct), + new Operation("DistributeStreams", SR.Keys.LogicalOpDistributeStreams, SR.Keys.DistributeStreamsDescription, "Parallelism_distribute.ico"), + new Operation("EagerSpool", SR.Keys.LogicalOpEagerSpool), + new Operation("Filter", SR.Keys.LogicalOpFilter), + new Operation("FlowDistinct", SR.Keys.LogicalOpFlowDistinct), + new Operation("FullOuterJoin", SR.Keys.LogicalOpFullOuterJoin), + new Operation("GatherStreams", SR.Keys.LogicalOpGatherStreams, SR.Keys.GatherStreamsDescription, "Parallelism_32x.ico"), + new Operation("IndexScan", SR.Keys.LogicalOpIndexScan), + new Operation("IndexSeek", SR.Keys.LogicalOpIndexSeek), + new Operation("InnerApply", SR.Keys.LogicalOpInnerApply), + new Operation("InnerJoin", SR.Keys.LogicalOpInnerJoin), + new Operation("Insert", SR.Keys.LogicalOpInsert), + new Operation("InsertedScan", SR.Keys.LogicalOpInsertedScan), + new Operation("IntersectAll", SR.Keys.LogicalOpIntersectAll), + new Operation("Intersect", SR.Keys.LogicalOpIntersect), + new Operation("KeyLookup", SR.Keys.LogicalKeyLookup), + new Operation("LazySpool", SR.Keys.LogicalOpLazySpool), + new Operation("LeftAntiSemiApply", SR.Keys.LogicalOpLeftAntiSemiApply), + new Operation("LeftAntiSemiJoin", SR.Keys.LogicalOpLeftAntiSemiJoin), + new Operation("LeftDiffAll", SR.Keys.LogicalOpLeftDiffAll), + new Operation("LeftDiff", SR.Keys.LogicalOpLeftDiff), + new Operation("LeftOuterApply", SR.Keys.LogicalOpLeftOuterApply), + new Operation("LeftOuterJoin", SR.Keys.LogicalOpLeftOuterJoin), + new Operation("LeftSemiApply", SR.Keys.LogicalOpLeftSemiApply), + new Operation("LeftSemiJoin", SR.Keys.LogicalOpLeftSemiJoin), + new Operation("LogRowScan", SR.Keys.LogicalOpLogRowScan), + new Operation("MergeInterval", SR.Keys.LogicalOpMergeInterval), + new Operation("ParameterTableScan", SR.Keys.LogicalOpParameterTableScan), + new Operation("PartialAggregate", SR.Keys.LogicalOpPartialAggregate), + new Operation("Print", SR.Keys.LogicalOpPrint), + new Operation("Put", SR.Keys.LogicalOpPut), + new Operation("Rank", SR.Keys.LogicalOpRank), + new Operation("ForeignKeyReferencesCheck", SR.Keys.LogicalOpForeignKeyReferencesCheck), + new Operation("RemoteDelete", SR.Keys.LogicalOpRemoteDelete), + new Operation("RemoteIndexScan", SR.Keys.LogicalOpRemoteIndexScan), + new Operation("RemoteIndexSeek", SR.Keys.LogicalOpRemoteIndexSeek), + new Operation("RemoteInsert", SR.Keys.LogicalOpRemoteInsert), + new Operation("RemoteQuery", SR.Keys.LogicalOpRemoteQuery), + new Operation("RemoteScan", SR.Keys.LogicalOpRemoteScan), + new Operation("RemoteUpdate", SR.Keys.LogicalOpRemoteUpdate), + new Operation("RepartitionStreams", SR.Keys.LogicalOpRepartitionStreams, SR.Keys.RepartitionStreamsDescription, "Parallelism_repartition.ico"), + new Operation("RIDLookup", SR.Keys.LogicalOpRIDLookup), + new Operation("RightAntiSemiJoin", SR.Keys.LogicalOpRightAntiSemiJoin), + new Operation("RightDiffAll", SR.Keys.LogicalOpRightDiffAll), + new Operation("RightDiff", SR.Keys.LogicalOpRightDiff), + new Operation("RightOuterJoin", SR.Keys.LogicalOpRightOuterJoin), + new Operation("RightSemiJoin", SR.Keys.LogicalOpRightSemiJoin), + new Operation("Segment", SR.Keys.LogicalOpSegment), + new Operation("Sequence", SR.Keys.LogicalOpSequence), + new Operation("Sort", SR.Keys.LogicalOpSort), + new Operation("Split", SR.Keys.LogicalOpSplit), + new Operation("Switch", SR.Keys.LogicalOpSwitch), + new Operation("Tablevaluedfunction", SR.Keys.LogicalOpTableValuedFunction), + new Operation("TableScan", SR.Keys.LogicalOpTableScan), + new Operation("Top", SR.Keys.LogicalOpTop), + new Operation("TopNSort", SR.Keys.LogicalOpTopNSort), + new Operation("UDX", SR.Keys.LogicalOpUDX), + new Operation("Union", SR.Keys.LogicalOpUnion), + new Operation("Update", SR.Keys.LogicalOpUpdate), + new Operation("Merge", SR.Keys.LogicalOpMerge), + new Operation("MergeStats", SR.Keys.LogicalOpMergeStats), + new Operation("LocalStats", SR.Keys.LogicalOpLocalStats), + new Operation("BatchHashTableBuild", SR.Keys.LogicalOpBatchHashTableBuild), + new Operation("WindowSpool", SR.Keys.LogicalOpWindow), + }; + + LogicalOperations = DictionaryFromList(logicalOperationList); + + /////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Statements + /// Name / Type SR Display Name Key SR Description Key Image + /////////////////////////////////////////////////////////////////////////////////////////////////////////// + // TODO: may need to put a few more statements in here + Operation[] statementList = new Operation[] + { + new Operation("SELECT", null, null, "Result_32x.ico"), + new Operation("COND", null, null, "If_32x.ico") + }; + + Statements = DictionaryFromList(statementList); + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Cursor types + /// Name / Type SR Display Name Key SR Description Key Image + /////////////////////////////////////////////////////////////////////////////////////////////////////////////// + Operation[] cursorTypeList = new Operation[] + { + new Operation("Dynamic", SR.Keys.Dynamic, SR.Keys.DynamicDescription, "Dynamic_32x.ico"), + new Operation("FastForward", SR.Keys.FastForward, SR.Keys.FastForwardDescription, "Cursor_catch_all_32x.ico"), + new Operation("Keyset", SR.Keys.Keyset, SR.Keys.KeysetDescription, "Keyset_32x.ico"), + new Operation("SnapShot", SR.Keys.Snapshot, SR.Keys.SnapshotDescription, "Snapshot_32x.ico") + }; + + CursorTypes = DictionaryFromList(cursorTypeList); + } + + private static Dictionary DictionaryFromList(Operation[] list) + { + Dictionary dictionary = new Dictionary(list.Length); + foreach (Operation item in list) + { + dictionary.Add(item.Name, item); + } + + return dictionary; + } + + private static string GetNameFromXmlEnumAttribute(string enumMemberName, Type enumType) + { + Debug.Assert(enumType.IsEnum); + + foreach (MemberInfo member in enumType.GetMembers()) + { + if (member.Name == enumMemberName) + { + object[] attributes = member.GetCustomAttributes(typeof(System.Xml.Serialization.XmlEnumAttribute), true); + foreach (System.Xml.Serialization.XmlEnumAttribute attribute in attributes) + { + return attribute.Name; + } + + break; + } + } + + // If nothing has been found, just return enumMemberName. + return enumMemberName; + } + + #endregion + + #region Private members + + private static readonly Dictionary PhysicalOperations; + private static readonly Dictionary LogicalOperations; + private static readonly Dictionary Statements; + private static readonly Dictionary CursorTypes; + + #endregion + + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/PropertyFactory.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/PropertyFactory.cs new file mode 100644 index 00000000..be8d63f0 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/PropertyFactory.cs @@ -0,0 +1,742 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.ComponentModel; +using System.Xml.Serialization; +using System.Reflection; +using System.Collections; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// PropertyFactory creates properties based on template properties (this class public properties) + /// + /// IMPORTANT: Property names should match those in ShowPlanXML classes + /// + /// Note: to hide a property from PropertyGrid, it should be defined + /// here with [Browsable(false)] attribute. + /// + /// + internal class PropertyFactory + { + #region Property templates + + [ShowInToolTip, DisplayOrder(0), DisplayNameDescription(SR.Keys.PhysicalOperation, SR.Keys.PhysicalOperationDesc)] + public string PhysicalOp { get { return null; } } + + [ShowInToolTip, DisplayOrder(1), DisplayNameDescription(SR.Keys.LogicalOperation, SR.Keys.LogicalOperationDesc)] + public string LogicalOp { get { return null; } } + + [ShowInToolTip, DisplayOrder(2), DisplayNameDescription(SR.Keys.EstimatedExecMode, SR.Keys.EstimatedExecModeDesc)] + public string EstimatedExecutionMode { get { return null; } } + + [ShowInToolTip, DisplayOrder(2), DisplayNameDescription(SR.Keys.ActualExecMode, SR.Keys.ActualExecModeDesc)] + public string ActualExecutionMode { get { return null; } } + + [ShowInToolTip, DisplayOrder(3), DisplayNameDescription(SR.Keys.Storage, SR.Keys.StorageDesc)] + public string Storage { get { return null; } } + + [ShowInToolTip, DisplayOrder(102), DisplayNameDescription(SR.Keys.EstimatedDataSize, SR.Keys.EstimatedDataSizeDescription)] + [TypeConverter(typeof(DataSizeTypeConverter))] + public double EstimatedDataSize { get { return 0; } } + + [ShowInToolTip, DisplayOrder(4), DisplayNameDescription(SR.Keys.NumberOfRows, SR.Keys.NumberOfRowsDescription)] + public double ActualRows { get { return 0; } } + + [ShowInToolTip, DisplayOrder(4), DisplayNameDescription(SR.Keys.ActualRowsRead, SR.Keys.ActualRowsReadDescription)] + public double ActualRowsRead { get { return 0; } } + + [ShowInToolTip, DisplayOrder(5), DisplayNameDescription(SR.Keys.NumberOfBatches, SR.Keys.NumberOfBatchesDescription)] + public double ActualBatches { get { return 0; } } + + [ShowInToolTip(LongString = true), DisplayOrder(6), DisplayNameDescription(SR.Keys.Statement, SR.Keys.StatementDesc)] + public string StatementText { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(6), DisplayNameDescription(SR.Keys.Predicate, SR.Keys.PredicateDescription)] + public string Predicate { get { return null; } } + + [ShowInToolTip, DisplayOrder(101), DisplayNameDescription(SR.Keys.EstimatedRowSize, SR.Keys.EstimatedRowSizeDescription)] + [TypeConverter(typeof(DataSizeTypeConverter))] + public int AvgRowSize { get { return 0; } } + + [ShowInToolTip, DisplayOrder(7), DisplayNameDescription(SR.Keys.CachedPlanSize, SR.Keys.CachedPlanSizeDescription)] + [TypeConverter(typeof(KBSizeTypeConverter))] + public int CachedPlanSize { get { return 0; } } + + [ShowInToolTip, DisplayOrder(7), DisplayNameDescription(SR.Keys.UsePlan)] + public bool UsePlan { get { return false; } } + + [ShowInToolTip, DisplayOrder(7), DisplayNameDescription(SR.Keys.ContainsInlineScalarTsqlUdfs)] + + public bool ContainsInlineScalarTsqlUdfs { get { return false; } } + + [ShowInToolTip, DisplayOrder(8), DisplayNameDescription(SR.Keys.EstimatedIoCost, SR.Keys.EstimatedIoCostDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double EstimateIO { get { return 0; } } + + [ShowInToolTip, DisplayOrder(8), DisplayNameDescription(SR.Keys.DegreeOfParallelism, SR.Keys.DegreeOfParallelismDescription)] + public int DegreeOfParallelism { get { return 0; } } + + [ShowInToolTip, DisplayOrder(8), DisplayNameDescription(SR.Keys.EffectiveDegreeOfParallelism, SR.Keys.EffectiveDegreeOfParallelismDescription)] + public int EffectiveDegreeOfParallelism { get { return 0; } } + + [ShowInToolTip, DisplayOrder(9), DisplayNameDescription(SR.Keys.EstimatedCpuCost, SR.Keys.EstimatedCpuCostDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double EstimateCPU { get { return 0; } } + + [ShowInToolTip, DisplayOrder(9), DisplayNameDescription(SR.Keys.MemoryGrant, SR.Keys.MemoryGrantDescription)] + [TypeConverter(typeof(KBSizeTypeConverter))] + public ulong MemoryGrant { get { return 0; } } + + [DisplayOrder(10), DisplayNameDescription(SR.Keys.ParameterList, SR.Keys.ParameterListDescription)] + public object ParameterList { get { return null; } } + + [ShowInToolTip, DisplayOrder(10), DisplayNameDescription(SR.Keys.NumberOfExecutions, SR.Keys.NumberOfExecutionsDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double ActualExecutions { get { return 0; } } + + [ShowInToolTip, DisplayOrder(10), DisplayNameDescription(SR.Keys.EstimatedNumberOfExecutions, SR.Keys.EstimatedNumberOfExecutionsDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + + public double EstimateExecutions { get { return 0; } } + + [ShowInToolTip(LongString = true), DisplayOrder(12), DisplayNameDescription(SR.Keys.ObjectShort, SR.Keys.ObjectDescription)] + public object Object { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.IndexKind, SR.Keys.IndexKindDescription)] + public string IndexKind { get { return null; } } + + [DisplayOrder(12), DisplayNameDescription(SR.Keys.OperationArgumentShort, SR.Keys.OperationArgumentDescription)] + public string Argument { get { return null; } } + + [ShowInToolTip, DisplayOrder(111), DisplayNameDescription(SR.Keys.ActualRebinds, SR.Keys.ActualRebindsDescription)] + public object ActualRebinds { get { return null; } } + + [ShowInToolTip, DisplayOrder(112), DisplayNameDescription(SR.Keys.ActualRewinds, SR.Keys.ActualRewindsDescription)] + + public object ActualRewinds { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualLocallyAggregatedRows, SR.Keys.ActualLocallyAggregatedRowsDescription)] + public object ActualLocallyAggregatedRows { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualElapsedms, SR.Keys.ActualElapsedmsDescription)] + public object ActualElapsedms { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualCPUms, SR.Keys.ActualCPUmsDescription)] + public object ActualCPUms { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualScans, SR.Keys.ActualScansDescription)] + public object ActualScans { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualLogicalReads, SR.Keys.ActualLogicalReadsDescription)] + public object ActualLogicalReads { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualPhysicalReads, SR.Keys.ActualPhysicalReadsDescription)] + public object ActualPhysicalReads { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualPageServerReads, SR.Keys.ActualPageServerReadsDescription)] + public object ActualPageServerReads { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualReadAheads, SR.Keys.ActualReadAheadsDescription)] + public object ActualReadAheads { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualPageServerReadAheads, SR.Keys.ActualPageServerReadAheadsDescription)] + public object ActualPageServerReadAheads { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualLobLogicalReads, SR.Keys.ActualLobLogicalReadsDescription)] + public object ActualLobLogicalReads { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualLobPhysicalReads, SR.Keys.ActualLobPhysicalReadsDescription)] + public object ActualLobPhysicalReads { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualLobPageServerReads, SR.Keys.ActualLobPageServerReadsDescription)] + public object ActualLobPageServerReads { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualLobReadAheads, SR.Keys.ActualLobReadAheadsDescription)] + public object ActualLobReadAheads { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualLobPageServerReadAheads, SR.Keys.ActualLobPageServerReadAheadsDescription)] + public object ActualLobPageServerReadAheads { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualIOStatistics, SR.Keys.ActualIOStatisticsDescription)] + public object ActualIOStatistics { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualTimeStatistics, SR.Keys.ActualTimeStatisticsDescription)] + public object ActualTimeStatistics { get { return null; } } + + [DisplayOrder(221), DisplayNameDescription(SR.Keys.ActualMemoryGrantStats, SR.Keys.ActualMemoryGrantStats)] + public object ActualMemoryGrantStats { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.HpcRowCount, SR.Keys.HpcRowCountDescription)] + public object HpcRowCount { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.HpcKernelElapsedUs, SR.Keys.HpcKernelElapsedUsDescription)] + public object HpcKernelElapsedUs { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.HpcHostToDeviceBytes, SR.Keys.HpcHostToDeviceBytesDescription)] + public object HpcHostToDeviceBytes { get { return null; } } + + [ShowInToolTip, DisplayOrder(221), DisplayNameDescription(SR.Keys.HpcDeviceToHostBytes, SR.Keys.HpcDeviceToHostBytesDescription)] + public object HpcDeviceToHostBytes { get { return null; } } + + [DisplayOrder(221), DisplayNameDescription(SR.Keys.InputMemoryGrant, SR.Keys.InputMemoryGrant)] + public object InputMemoryGrant { get { return null; } } + + [DisplayOrder(221), DisplayNameDescription(SR.Keys.OutputMemoryGrant, SR.Keys.OutputMemoryGrant)] + public object OutputMemoryGrant { get { return null; } } + + [DisplayOrder(221), DisplayNameDescription(SR.Keys.UsedMemoryGrant, SR.Keys.UsedMemoryGrant)] + public object UsedMemoryGrant { get { return null; } } + + [ShowInToolTip, DisplayOrder(2), DisplayNameDescription(SR.Keys.IsGraphDBTransitiveClosure, SR.Keys.IsGraphDBTransitiveClosureDescription)] + public bool IsGraphDBTransitiveClosure { get { return false; } } + + [ShowInToolTip, DisplayOrder(2), DisplayNameDescription(SR.Keys.IsInterleavedExecuted, SR.Keys.IsInterleavedExecutedDescription)] + public bool IsInterleavedExecuted { get { return false; } } + + [ShowInToolTip, DisplayOrder(2), DisplayNameDescription(SR.Keys.IsAdaptive, SR.Keys.IsAdaptiveDescription)] + public bool IsAdaptive { get { return false; } } + + [ShowInToolTip, DisplayOrder(2), DisplayNameDescription(SR.Keys.AdaptiveThresholdRows, SR.Keys.AdaptiveThresholdRowsDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double AdaptiveThresholdRows { get { return 0; } } + + [ShowInToolTip, DisplayOrder(2), DisplayNameDescription(SR.Keys.EstimatedJoinType, SR.Keys.EstimatedJoinTypeDescription)] + public string EstimatedJoinType { get { return null; } } + + [ShowInToolTip, DisplayOrder(2), DisplayNameDescription(SR.Keys.ActualJoinType, SR.Keys.ActualJoinTypeDescription)] + public string ActualJoinType { get { return null; } } + + [ShowInToolTip, DisplayOrder(100), DisplayNameDescription(SR.Keys.EstimatedNumberOfRowsPerExecution, SR.Keys.EstimatedNumberOfRowsPerExecutionDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double EstimateRows { get { return 0; } } + + [ShowInToolTip, DisplayOrder(100), DisplayNameDescription(SR.Keys.EstimatedNumberOfRowsPerExecution, SR.Keys.EstimatedNumberOfRowsPerExecutionDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double StatementEstRows { get { return 0; } } + + [ShowInToolTip, DisplayOrder(100), DisplayNameDescription(SR.Keys.EstimatedNumberOfRowsForAllExecutions, SR.Keys.EstimatedNumberOfRowsForAllExecutionsDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double EstimateRowsAllExecs { get { return 0; } } + + [ShowInToolTip, DisplayOrder(100), DisplayNameDescription(SR.Keys.EstimatedNumberOfRowsForAllExecutions, SR.Keys.EstimatedNumberOfRowsForAllExecutionsDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double StatementEstRowsAllExecs { get { return 0; } } + + [ShowInToolTip, DisplayOrder(100), DisplayNameDescription(SR.Keys.EstimatedRowsRead, SR.Keys.EstimatedRowsReadDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double EstimatedRowsRead { get { return 0; } } + + [DisplayOrder(101), DisplayNameDescription(SR.Keys.EstimatedRebinds, SR.Keys.EstimatedRebindsDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double EstimateRebinds { get { return 0; } } + + [DisplayOrder(102), DisplayNameDescription(SR.Keys.EstimatedRewinds, SR.Keys.EstimatedRewindsDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double EstimateRewinds { get { return 0; } } + + [DisplayOrder(200), DisplayNameDescription(SR.Keys.DefinedValues, SR.Keys.DefinedValuesDescription)] + public string DefinedValues { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(201), DisplayNameDescription(SR.Keys.OutputList, SR.Keys.OutputListDescription)] + public object OutputList { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(202), DisplayNameDescription(SR.Keys.Warnings, SR.Keys.WarningsDescription)] + public object Warnings { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.Parallel, SR.Keys.ParallelDescription)] + public bool Parallel { get { return false; } } + + [DisplayOrder(204), DisplayNameDescription(SR.Keys.SetOptions, SR.Keys.SetOptionsDescription)] + public object StatementSetOptions { get { return null; } } + + [DisplayOrder(205), DisplayNameDescription(SR.Keys.OptimizationLevel, SR.Keys.OptimizationLevelDescription)] + public string StatementOptmLevel { get { return null; } } + + [DisplayOrder(206), DisplayNameDescription(SR.Keys.StatementOptmEarlyAbortReason)] + public string StatementOptmEarlyAbortReason { get { return null; } } + + [DisplayOrder(211), DisplayNameDescription(SR.Keys.MemoryFractions, SR.Keys.MemoryFractionsDescription)] + public object MemoryFractions { get { return null; } } + + [DisplayOrder(211), DisplayNameDescription(SR.Keys.MemoryFractionsInput, SR.Keys.MemoryFractionsInputDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double Input { get { return 0; } } + + [DisplayOrder(212), DisplayNameDescription(SR.Keys.MemoryFractionsOutput, SR.Keys.MemoryFractionsOutputDescription)] + [TypeConverter(typeof(FloatTypeConverter))] + public double Output { get { return 0; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.RemoteDestination, SR.Keys.RemoteDestinationDescription)] + public string RemoteDestination { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.RemoteObject, SR.Keys.RemoteObjectDescription)] + public string RemoteObject { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.RemoteSource, SR.Keys.RemoteSourceDescription)] + public string RemoteSource { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.RemoteQuery, SR.Keys.RemoteQueryDescription)] + public string RemoteQuery { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.UsedUdxColumns, SR.Keys.UsedUdxColumnsDescription)] + public object UsedUDXColumns { get { return null; } } + + [ShowInToolTip, DisplayOrder(204), DisplayNameDescription(SR.Keys.UdxName, SR.Keys.UdxNameDescription)] + public string UDXName { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.InnerSideJoinColumns, SR.Keys.InnerSideJoinColumnsDescription)] + public object InnerSideJoinColumns { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(204), DisplayNameDescription(SR.Keys.OuterSideJoinColumns, SR.Keys.OuterSideJoinColumnsDescription)] + public object OuterSideJoinColumns { get { return null; } } + + [DisplayOrder(205), DisplayNameDescription(SR.Keys.Residual, SR.Keys.ResidualDescription)] + public string Residual { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(206), DisplayNameDescription(SR.Keys.PassThru, SR.Keys.PassThruDescription)] + public string PassThru { get { return null; } } + + [ShowInToolTip, DisplayOrder(207), DisplayNameDescription(SR.Keys.ManyToMany, SR.Keys.ManyToManyDescription)] + public bool ManyToMany { get { return false; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.PartitionColumns, SR.Keys.PartitionColumnsDescription)] + public object PartitionColumns { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(204), DisplayNameDescription(SR.Keys.OrderBy, SR.Keys.OrderByDescription)] + public object OrderBy { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(205), DisplayNameDescription(SR.Keys.HashKeys, SR.Keys.HashKeysDescription)] + public object HashKeys { get { return null; } } + + [ShowInToolTip, DisplayOrder(206), DisplayNameDescription(SR.Keys.ProbeColumn, SR.Keys.ProbeColumnDescription)] + public object ProbeColumn { get { return null; } } + + [ShowInToolTip, DisplayOrder(207), DisplayNameDescription(SR.Keys.PartitioningType, SR.Keys.PartitioningTypeDescription)] + public string PartitioningType { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.GroupBy, SR.Keys.GroupByDescription)] + public object GroupBy { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.GroupingSets, SR.Keys.GroupingSetsDescription)] + public object GroupingSets { get { return null; } } + + [DisplayOrder(200), DisplayNameDescription(SR.Keys.RollupInfo, SR.Keys.RollupInfoDescription)] + public object RollupInfo { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.HighestLevel, SR.Keys.HighestLevelDescription)] + public object HighestLevel { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.RollupLevel, SR.Keys.RollupLevelDescription)] + [Browsable(true), ImmutableObject(true)] + public object RollupLevel { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.Level, SR.Keys.LevelDescription)] + public object Level { get { return null; } } + + [ShowInToolTip, DisplayOrder(203), DisplayNameDescription(SR.Keys.SegmentColumn, SR.Keys.SegmentColumnDescription)] + public object SegmentColumn { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.HashKeysBuild, SR.Keys.HashKeysBuildDescription)] + public object HashKeysBuild { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.HashKeysProbe, SR.Keys.HashKeysProbeDescription)] + public object HashKeysProbe { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.BuildResidual, SR.Keys.BuildResidualDescription)] + public string BuildResidual { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.ProbeResidual, SR.Keys.ProbeResidualDescription)] + public string ProbeResidual { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.SetPredicate, SR.Keys.SetPredicateDescription)] + public string SetPredicate { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.RankColumns, SR.Keys.RankColumnsDescription)] + public object RankColumns { get { return null; } } + + [ShowInToolTip, DisplayOrder(203), DisplayNameDescription(SR.Keys.ActionColumn, SR.Keys.ActionColumnDescription)] + public object ActionColumn { get { return null; } } + + [ShowInToolTip, DisplayOrder(203), DisplayNameDescription(SR.Keys.OriginalActionColumn, SR.Keys.OriginalActionColumnDescription)] + public object OriginalActionColumn { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.Rows, SR.Keys.RowsDescription)] + public int Rows { get { return 0; } } + + [ShowInToolTip, DisplayOrder(150), DisplayNameDescription(SR.Keys.Partitioned, SR.Keys.PartitionedDescription)] + public object Partitioned { get { return null; } } + + [DisplayOrder(156), DisplayNameDescription(SR.Keys.PartitionsAccessed)] + public object PartitionsAccessed { get { return null; } } + + [ShowInToolTip, DisplayOrder(152), DisplayNameDescription(SR.Keys.PartitionCount)] + public object PartitionCount { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.TieColumns, SR.Keys.TieColumnsDescription)] + public object TieColumns { get { return null; } } + + [ShowInToolTip, DisplayOrder(203), DisplayNameDescription(SR.Keys.IsPercent, SR.Keys.IsPercentDescription)] + public bool IsPercent { get { return false; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.WithTies, SR.Keys.WithTiesDescription)] + public bool WithTies { get { return false; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.TopExpression, SR.Keys.TopExpressionDescription)] + public string TopExpression { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.Distinct, SR.Keys.DistinctDescription)] + public bool Distinct { get { return false; } } + + [ShowInToolTip(LongString = true), DisplayOrder(205), DisplayNameDescription(SR.Keys.OuterReferences, SR.Keys.OuterReferencesDescription)] + public object OuterReferences { get { return null; } } + + [ShowInToolTip, DisplayOrder(203), DisplayNameDescription(SR.Keys.PartitionId, SR.Keys.PartitionIdDescription)] + public object PartitionId { get { return null; } } + + [ShowInToolTip, DisplayOrder(203), DisplayNameDescription(SR.Keys.Ordered, SR.Keys.OrderedDescription)] + public bool Ordered { get { return false; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.ScanDirection, SR.Keys.ScanDirectionDescription)] + public object ScanDirection { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.SeekPredicate, SR.Keys.SeekPredicateDescription)] + public object SeekPredicate { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.SeekPredicate, SR.Keys.SeekPredicateDescription)] + public object SeekPredicateNew { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(203), DisplayNameDescription(SR.Keys.SeekPredicate, SR.Keys.SeekPredicateDescription)] + public object SeekPredicatePart { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(205), DisplayNameDescription(SR.Keys.SeekPredicates, SR.Keys.SeekPredicatesDescription)] + public string SeekPredicates { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.ForcedIndex, SR.Keys.ForcedIndexDescription)] + public bool ForcedIndex { get { return false; } } + + [ShowInToolTip(LongString = true), DisplayOrder(5), DisplayNameDescription(SR.Keys.Values, SR.Keys.ValuesDescription)] + public object Values { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.ColumnsWithNoStatistics, SR.Keys.ColumnsWithNoStatisticsDescription)] + public object ColumnsWithNoStatistics { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.NoJoinPredicate, SR.Keys.NoJoinPredicateDescription)] + public bool NoJoinPredicate { get { return false; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.SpillToTempDb, SR.Keys.SpillToTempDbDescription)] + public object SpillToTempDb { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.StartupExpression, SR.Keys.StartupExpressionDescription)] + public bool StartupExpression { get { return false; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.Query)] + public string Query { get { return null; } } + + [DisplayOrder(203), DisplayNameDescription(SR.Keys.Stack)] + public bool Stack { get { return false; } } + + [ShowInToolTip, DisplayOrder(203), DisplayNameDescription(SR.Keys.RowCount)] + public bool RowCount { get { return false; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.Optimized)] + public bool Optimized { get { return false; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.WithPrefetch)] + public bool WithPrefetch { get { return false; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.Prefix)] + public object Prefix { get { return null; } } + + [DisplayOrder(7), DisplayNameDescription(SR.Keys.StartRange, SR.Keys.StartRangeDescription)] + public object StartRange { get { return null; } } + + [DisplayOrder(8), DisplayNameDescription(SR.Keys.EndRange, SR.Keys.EndRangeDescription)] + public object EndRange { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.RangeColumns)] + public object RangeColumns { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.RangeExpressions)] + public object RangeExpressions { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ScanType)] + public object ScanType { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ColumnReference)] + public object ColumnReference { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ObjectServer, SR.Keys.ObjectServerDescription)] + public string Server { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ObjectDatabase, SR.Keys.ObjectDatabaseDescription)] + public string Database { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ObjectIndex, SR.Keys.ObjectIndexDescription)] + public string Index { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ObjectSchema, SR.Keys.ObjectSchemaDescription)] + public string Schema { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ObjectTable, SR.Keys.ObjectTableDescription)] + public string Table { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ObjectAlias, SR.Keys.ObjectAliasDescription)] + public string Alias { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ObjectColumn, SR.Keys.ObjectColumnDescription)] + public string Column { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ObjectComputedColumn, SR.Keys.ObjectComputedColumnDescription)] + public bool ComputedColumn { get { return false; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ParameterDataType)] + public string ParameterDataType { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ParameterCompiledValue)] + public string ParameterCompiledValue { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ParameterRuntimeValue)] + public string ParameterRuntimeValue { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.CursorPlan)] + public object CursorPlan { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.CursorOperation)] + public object Operation { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.CursorName)] + public string CursorName { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.CursorActualType)] + public object CursorActualType { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.CursorRequestedType)] + public object CursorRequestedType { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.CursorConcurrency)] + public object CursorConcurrency { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.ForwardOnly)] + public bool ForwardOnly { get { return false; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.QueryPlan)] + public object QueryPlan { get { return null; } } + + [DisplayOrder(6), DisplayNameDescription(SR.Keys.OperationType)] + public object OperationType { get { return null; } } + + [ShowInToolTip, DisplayOrder(300), DisplayNameDescription(SR.Keys.NodeId)] + public int NodeId { get { return 0; } } + + [ShowInToolTip, DisplayOrder(301), DisplayNameDescription(SR.Keys.PrimaryNodeId)] + public int PrimaryNodeId { get { return 0; } } + + [ShowInToolTip, DisplayOrder(302), DisplayNameDescription(SR.Keys.ForeignKeyReferencesCount)] + public int ForeignKeyReferencesCount { get { return 0; } } + + [ShowInToolTip, DisplayOrder(303), DisplayNameDescription(SR.Keys.NoMatchingIndexCount)] + public int NoMatchingIndexCount { get { return 0; } } + + [ShowInToolTip, DisplayOrder(304), DisplayNameDescription(SR.Keys.PartialMatchingIndexCount)] + public int PartialMatchingIndexCount { get { return 0; } } + + [ShowInToolTip(LongString = true), DisplayOrder(6), DisplayNameDescription(SR.Keys.WhereJoinColumns)] + public object WhereJoinColumns { get { return null; } } + + [ShowInToolTip(LongString = true), DisplayOrder(6), DisplayNameDescription(SR.Keys.ProcName)] + public string ProcName { get { return null; } } + + [DisplayOrder(400), DisplayNameDescription(SR.Keys.InternalInfo)] + public object InternalInfo { get { return null; } } + + [ShowInToolTip, DisplayOrder(220), DisplayNameDescription(SR.Keys.RemoteDataAccess, SR.Keys.RemoteDataAccessDescription)] + public bool RemoteDataAccess { get { return false; } } + + [DisplayOrder(220), DisplayNameDescription(SR.Keys.CloneAccessScope, SR.Keys.CloneAccessScopeDescription)] + public string CloneAccessScope { get { return null; } } + + [ShowInToolTip, DisplayOrder(220), DisplayNameDescription(SR.Keys.Remoting, SR.Keys.RemotingDescription)] + public bool Remoting { get { return false; } } + + [DisplayOrder(201), DisplayNameDescription(SR.Keys.Activation)] + public object Activation { get { return null; } } + + [DisplayOrder(201), DisplayNameDescription(SR.Keys.BrickRouting)] + public object BrickRouting { get { return null; } } + + [DisplayOrder(201), DisplayNameDescription(SR.Keys.FragmentIdColumn)] + public object FragmentIdColumn { get { return null; } } + public string CardinalityEstimationModelVersion { get { return null; } } + public string CompileCPU { get { return null; } } + public string CompileMemory { get { return null; } } + public string CompileTime { get { return null; } } + public string NonParallelPlanReason { get { return null; } } + public string QueryHash { get { return null; } } + public string QueryPlanHash { get { return null; } } + public bool RetrievedFromCache { get { return false; } } + public bool SecurityPolicyApplied { get { return false; } } + public bool NoExpandHint { get { return false; } } + public double TableCardinality { get { return 0; } } + + #endregion + + #region Non-browsable properties + + // The following properties should be hidden from UI + + + [Browsable(false)] + public string PhysicalOperationKind { get { return null; } } + + [Browsable(false)] + public double EstimatedTotalSubtreeCost { get { return 0; } } + + [Browsable(false)] + public double StatementSubTreeCost { get { return 0; } } + + [Browsable(false)] + public double TotalSubtreeCost { get { return 0; } } + + [Browsable(false)] + public int Parent { get { return 0; } } + + [Browsable(false)] + public int StatementId { get { return 0; } } + + [Browsable(false)] + public int StatementCompId { get { return 0; } } + + [Browsable(false)] + public object RunTimeInformation { get { return null; } } + + [Browsable(false)] + public object StatementType { get { return null; } } + + /// + /// Run time partition summary should not show up as one node. Details such as PartitionsAccessed is displayed in individually. + /// + [Browsable(false)] + public object RunTimePartitionSummary { get { return null; } } + [Browsable(false)] + public object SkeletonNode { get { return null; } } + [Browsable(false)] + public object SkeletonHasMatch { get { return null; } } + + #endregion + + #region CreateProperty + public static PropertyDescriptor CreateProperty(PropertyDescriptor property, object value) + { + Type type = null; + + // In case of xml Choice group, the property name can be general like "Item" or "Items". + // The real names are specified by XmlElementAttributes. We need to save the type of + // value to extract its original name from its XmlElementAttribute. + if (property.Name == "Items" || property.Name == "Item") + { + type = value.GetType(); + } + + // Convert value if ObjectWrapperTypeConverter supports it + if (ObjectWrapperTypeConverter.Default.CanConvertFrom(property.PropertyType)) + { + value = ObjectWrapperTypeConverter.Default.ConvertFrom(value); + } + + if (value == null) + { + return null; + } + + PropertyDescriptor templateProperty = Properties[property.Name]; + + if (templateProperty != null) + { + return new PropertyValue(templateProperty, value); + } + else + { + IEnumerable attributeCollection = property.Attributes; + string propertyName = property.Name; + + // In case of xml Choice group, the property name can be general like "Item" or "Items". + // The real names are specified by XmlElementAttributes. property.Attributes does not + // return all the attributes. Hence we need extract custom attributes through + // PropertyInfo class. + if (type != null) + { + attributeCollection = PropertyFactory.GetAttributeCollectionForChoiceElement(property); + } + + foreach (object attrib in attributeCollection) + { + XmlElementAttribute attribute = attrib as XmlElementAttribute; + + if (attribute != null && !string.IsNullOrEmpty(attribute.ElementName)) + { + if ((type == null) || (type.Equals(attribute.Type))) + { + propertyName = attribute.ElementName; + + templateProperty = Properties[propertyName]; + if (templateProperty != null) + { + return new PropertyValue(templateProperty, value); + } + } + } + } + + // TODO: review this debug code + return new PropertyValue(propertyName, value); + } + } + + private static IEnumerable GetAttributeCollectionForChoiceElement(PropertyDescriptor property) + { + Type type = property.ComponentType; + PropertyInfo pInfo = type.GetProperty("Items"); + + if (pInfo == null) + { + //Try using item. + pInfo = type.GetProperty("Item"); + } + + if (pInfo != null) + { + return pInfo.GetCustomAttributes(true); + } + + return property.Attributes; + } + public static PropertyDescriptor CreateProperty(string propertyName, object value) + { + PropertyDescriptor templateProperty = Properties[propertyName]; + + if (templateProperty != null) + { + return new PropertyValue(templateProperty, value); + } + else + { + // TODO: review this debug code + return new PropertyValue(propertyName, value); + } + } + + #endregion + + #region Implementation details + + private PropertyFactory() { } + + private static PropertyDescriptorCollection Properties = TypeDescriptor.GetProperties(typeof(PropertyFactory)); + + #endregion + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/PropertyValue.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/PropertyValue.cs new file mode 100644 index 00000000..672b33e2 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/PropertyValue.cs @@ -0,0 +1,231 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections; +using System.ComponentModel; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + internal sealed class PropertyValue : PropertyDescriptor + { + #region Constructors + + public PropertyValue(string name, object value) + : base(name, null) + { + this.propertyValue = value; + } + + public PropertyValue(PropertyDescriptor baseProperty, object value) + : this(baseProperty.Name, value) + { + this.baseProperty = baseProperty; + } + + #endregion + + #region Public methods and properties + + public object Value + { + get { return this.propertyValue; } + set { this.propertyValue = value; } + } + + public int DisplayOrder + { + get + { + InitializeDisplayAttributesIfNecessary(); + return this.displayOrder; + } + } + + public bool IsLongString + { + get + { + InitializeDisplayAttributesIfNecessary(); + return this.isLongString; + } + } + + public void SetDisplayNameAndDescription(string newDisplayName, string newDescription) + { + this.displayName = newDisplayName; + this.description = newDescription; + } + + #endregion + + #region PropertyDesciptor overrides + + public override AttributeCollection Attributes + { + get + { + return this.baseProperty != null ? baseProperty.Attributes : base.Attributes; + } + } + + public override bool CanResetValue(object component) + { + return false; + } + + public override bool IsReadOnly + { + get { return true; } + } + + public override Type ComponentType + { + get { return this.GetType(); } + } + + public override Type PropertyType + { + get { return this.propertyValue != null ? this.propertyValue.GetType() : typeof(string); } + } + + public override object GetValue(object component) + { + return this.propertyValue; + } + + public override void ResetValue(object component) + { + } + + public override void SetValue(object component, object value) + { + } + + public override bool ShouldSerializeValue(object component) + { + return false; + } + + public override string DisplayName + { + get + { + InitializeDisplayAttributesIfNecessary(); + + if (this.displayName != null || this.displayNameKey != null) + { + if (this.displayName == null) + { + this.displayName = SR.Keys.GetString(this.displayNameKey); + } + + return this.displayName; + } + + return base.DisplayName; + } + } + + public override string Description + { + get + { + InitializeDisplayAttributesIfNecessary(); + + if (this.description != null || this.descriptionKey != null) + { + if (this.description == null) + { + this.description = SR.Keys.GetString(this.descriptionKey); + } + + return this.description; + } + + return base.Description; + } + } + + #endregion + + private void InitializeDisplayAttributesIfNecessary() + { + if (this.initialized) + { + return; + } + + this.initialized = true; + + DisplayNameDescriptionAttribute displayNameDescriptionAttribute = + Attributes[typeof(DisplayNameDescriptionAttribute)] as DisplayNameDescriptionAttribute; + if (displayNameDescriptionAttribute != null) + { + this.displayNameKey = displayNameDescriptionAttribute.DisplayName; + this.descriptionKey = displayNameDescriptionAttribute.Description; + if (this.descriptionKey == null) + { + this.descriptionKey = this.displayNameKey; + } + } + + DisplayOrderAttribute displayOrderAttribute = + Attributes[typeof(DisplayOrderAttribute)] as DisplayOrderAttribute; + if (displayOrderAttribute != null) + { + this.displayOrder = displayOrderAttribute.DisplayOrder; + } + + ShowInToolTipAttribute showInToolTipAttribute = + Attributes[typeof(ShowInToolTipAttribute)] as ShowInToolTipAttribute; + if (showInToolTipAttribute != null) + { + this.isLongString = showInToolTipAttribute.LongString; + } + } + + #region Private members + + private object propertyValue; + private string displayName; + private string displayNameKey; + private string description; + private string descriptionKey; + private int displayOrder = Int32.MaxValue; + private PropertyDescriptor baseProperty; + private bool isLongString; + private bool initialized; + + #endregion + + #region OrderComparer + + internal sealed class OrderComparer : IComparer + { + int IComparer.Compare(object x, object y) + { + return Compare(x as PropertyValue, y as PropertyValue); + } + + private static int Compare(PropertyValue x, PropertyValue y) + { + if (x.IsLongString != y.IsLongString) + { + return x.IsLongString ? 1 : -1; + } + + int orderOfX = x != null ? x.DisplayOrder : Int32.MaxValue - 1; + int orderOfY = y != null ? y.DisplayOrder : Int32.MaxValue - 1; + + return orderOfX - orderOfY; + } + + public static readonly OrderComparer Default = new OrderComparer(); + } + + #endregion + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/RelOpBaseTypeParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/RelOpBaseTypeParser.cs new file mode 100644 index 00000000..bf9d2a8b --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/RelOpBaseTypeParser.cs @@ -0,0 +1,83 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.ComponentModel; +using System.Collections; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Parses ShowPlan XML objects derived from RelOpBaseType type + /// + internal class RelOpBaseTypeParser : XmlPlanParser + { + /// + /// This function doesn't do anything. It simply returns the parent node + /// passed it. + /// + /// Item being parsed. + /// Parent item. + /// Parent node. + /// Node builder context. + /// The node that corresponds to the item being parsed. + public override Node GetCurrentNode(object item, object parentItem, Node parentNode, NodeBuilderContext context) + { + return parentNode; + } + + /// + /// Enumerates children items of the item being parsed. + /// + /// The item being parsed. + /// Enumeration. + public override IEnumerable GetChildren(object parsedItem) + { + PropertyDescriptor relOpProperty = TypeDescriptor.GetProperties(parsedItem)["RelOp"]; + if (relOpProperty != null) + { + object value = relOpProperty.GetValue(parsedItem); + if (value != null) + { + if (value is IEnumerable) + { + foreach (object item in (IEnumerable)value) + { + yield return item; + } + } + else + { + yield return value; + } + } + } + + yield break; + } + + /// + /// Protected constructor prevents this object from being externally instantiated + /// + protected RelOpBaseTypeParser() + { + } + + /// + /// Singelton instance + /// + private static RelOpBaseTypeParser relOpBaseTypeParser = null; + public static RelOpBaseTypeParser Instance + { + get + { + if (relOpBaseTypeParser == null) + { + relOpBaseTypeParser = new RelOpBaseTypeParser(); + } + return relOpBaseTypeParser; + } + } + } +} \ No newline at end of file diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/RelOpTypeParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/RelOpTypeParser.cs new file mode 100644 index 00000000..9645a538 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/RelOpTypeParser.cs @@ -0,0 +1,733 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Text; +using System.Collections; +using System.ComponentModel; +using System.Diagnostics; +using System.Globalization; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + internal sealed class RelOpTypeParser : XmlPlanParser + { + #region Constants + private const string OPERATION_INDEX_DELETE = "IndexDelete"; + private const string OPERATION_CLUSTERED_INDEX_DELETE = "ClusteredIndexDelete"; + private const string OPERATION_COLUMNSTORE_INDEX_DELETE = "ColumnstoreIndexDelete"; + + private const string OPERATION_INDEX_INSERT = "IndexInsert"; + private const string OPERATION_CLUSTERED_INDEX_INSERT = "ClusteredIndexInsert"; + private const string OPERATION_COLUMNSTORE_INDEX_INSERT = "ColumnstoreIndexInsert"; + + private const string OPERATION_INDEX_MERGE = "IndexMerge"; + private const string OPERATION_CLUSTERED_INDEX_MERGE = "ClusteredIndexMerge"; + private const string OPERATION_COLUMNSTORE_INDEX_MERGE = "ColumnstoreIndexMerge"; + + private const string OPERATION_INDEX_SCAN = "IndexScan"; + private const string OPERATION_CLUSTERED_INDEX_SCAN = "ClusteredIndexScan"; + private const string OPERATION_COLUMNSTORE_INDEX_SCAN = "ColumnstoreIndexScan"; + + private const string OPERATION_INDEX_UPDATE = "IndexUpdate"; + private const string OPERATION_CLUSTERED_INDEX_UPDATE = "ClusteredIndexUpdate"; + private const string OPERATION_COLUMNSTORE_INDEX_UPDATE = "ColumnstoreIndexUpdate"; + + private const string OBJECT_NODE = "Object"; + private const string STORAGE_PROPERTY = "Storage"; + #endregion + + /// + /// Creates new node and adds it to the graph. + /// + /// Item being parsed. + /// Parent item. + /// Parent node. + /// Node builder context. + /// The node that corresponds to the item being parsed. + public override Node GetCurrentNode(object item, object parentItem, Node parentNode, NodeBuilderContext context) + { + return NewNode(context); + } + + /// + /// Enumerates children items of the item being parsed. + /// + /// The item being parsed. + /// Enumeration. + public override IEnumerable GetChildren(object parsedItem) + { + RelOpType item = parsedItem as RelOpType; + if (item.Item != null) + { + yield return item.Item; + } + + yield break; + } + + /// + /// Determines Operation that corresponds to the object being parsed. + /// + /// Node being parsed. + /// Operation that corresponds to the node. + protected override Operation GetNodeOperation(Node node) + { + object physicalOpType = node["PhysicalOp"]; + object logicalOpType = node["LogicalOp"]; + + if (physicalOpType == null || logicalOpType == null) + { + throw new FormatException(SR.Keys.UnknownShowPlanSource); + } + + string physicalOpTypeName = physicalOpType.ToString(); + string logicalOpTypeName = logicalOpType.ToString(); + + // SQLBU# 434739: Custom description and icons for KeyLookup operation: + // + // SQL Server 2005 doesnt expose 'KeyLookup' operations as thier own type, + // instead they indicate Bookmark operations as a 'ClusteredIndexSeek' op + // that is having Lookup=true. Users have to select the actual node to tell + // if a ClusteredIndexSeek is an actual bookmark operation or not. + // + // Our request for having engine expose the Bookmark operation as its own type, + // instead of exposing it as a 'ClusteredIndexSeek' cannot be addressed by + // engine in SP2 timeframe (reasons include compatibility on published showplanxml.xsd + // schema as well as amount of changes in components that consume the xml showplan) + // + // For SP2 timeframe the solution is to do an aesthetic only change: + // SSMS interprets the xml showplan and provides custom icons and descriptions + // for a new operation: 'KeyLookup', that is getting documented in BOL. + const string operationClusteredIndexSeek = "ClusteredIndexSeek"; + const string operationKeyLookup = "KeyLookup"; + + object lookup = node["Lookup"]; + if ((lookup != null) && (lookup is System.Boolean)) + { + if (Convert.ToBoolean(lookup) == true) + { + if (0 == string.Compare(physicalOpTypeName, operationClusteredIndexSeek, StringComparison.OrdinalIgnoreCase)) + { + physicalOpTypeName = operationKeyLookup; + } + if (0 == string.Compare(logicalOpTypeName, operationClusteredIndexSeek, StringComparison.OrdinalIgnoreCase)) + { + logicalOpTypeName = operationKeyLookup; + } + } + } + + /* + * For index scans, Storage property should be read from this node. + * Otherwise, for DML operations, Storage property should be read from this node's child "Object" element. + */ + if (0 == string.Compare(physicalOpTypeName, OPERATION_INDEX_SCAN, StringComparison.OrdinalIgnoreCase) || + 0 == string.Compare(physicalOpTypeName, OPERATION_CLUSTERED_INDEX_SCAN, StringComparison.OrdinalIgnoreCase)) + { + object storage = node[STORAGE_PROPERTY]; + if ((storage != null) && (storage.Equals(StorageType.ColumnStore))) + { + physicalOpTypeName = OPERATION_COLUMNSTORE_INDEX_SCAN; + } + } + else + { + ExpandableObjectWrapper objectWrapper = (ExpandableObjectWrapper)node[OBJECT_NODE]; + if (objectWrapper != null) + { + PropertyValue storagePropertyValue = (PropertyValue)objectWrapper.Properties[STORAGE_PROPERTY]; + + /* + * If object's storage is of type Storage.Columnstore, + * PhysicalOperations should be updated to their columnstore counterparts. + */ + if (storagePropertyValue != null && ((storagePropertyValue).Value.Equals(StorageType.ColumnStore))) + { + if (0 == string.Compare(physicalOpTypeName, OPERATION_INDEX_DELETE, StringComparison.OrdinalIgnoreCase) || + 0 == string.Compare(physicalOpTypeName, OPERATION_CLUSTERED_INDEX_DELETE, StringComparison.OrdinalIgnoreCase)) + { + physicalOpTypeName = OPERATION_COLUMNSTORE_INDEX_DELETE; + } + else if (0 == string.Compare(physicalOpTypeName, OPERATION_INDEX_INSERT, StringComparison.OrdinalIgnoreCase) || + 0 == string.Compare(physicalOpTypeName, OPERATION_CLUSTERED_INDEX_INSERT, StringComparison.OrdinalIgnoreCase)) + { + physicalOpTypeName = OPERATION_COLUMNSTORE_INDEX_INSERT; + } + else if (0 == string.Compare(physicalOpTypeName, OPERATION_INDEX_MERGE, StringComparison.OrdinalIgnoreCase) || + 0 == string.Compare(physicalOpTypeName, OPERATION_CLUSTERED_INDEX_MERGE, StringComparison.OrdinalIgnoreCase)) + { + physicalOpTypeName = OPERATION_COLUMNSTORE_INDEX_MERGE; + } + else if (0 == string.Compare(physicalOpTypeName, OPERATION_INDEX_UPDATE, StringComparison.OrdinalIgnoreCase) || + 0 == string.Compare(physicalOpTypeName, OPERATION_CLUSTERED_INDEX_UPDATE, StringComparison.OrdinalIgnoreCase)) + { + physicalOpTypeName = OPERATION_COLUMNSTORE_INDEX_UPDATE; + } + } + } + } + + Operation physicalOp = OperationTable.GetPhysicalOperation(physicalOpTypeName); + Operation logicalOp = OperationTable.GetLogicalOperation(logicalOpTypeName); + + Operation resultOp = logicalOp != null && logicalOp.Image != null && logicalOp.Description != null + ? logicalOp : physicalOp; + + node.LogicalOpUnlocName = logicalOpTypeName; + node.PhysicalOpUnlocName = physicalOpTypeName; + node["PhysicalOp"] = physicalOp.DisplayName; + node["LogicalOp"] = logicalOp.DisplayName; + + Debug.Assert(logicalOp.DisplayName != null); + Debug.Assert(physicalOp.DisplayName != null); + Debug.Assert(resultOp.Description != null); + Debug.Assert(resultOp.Image != null); + + return resultOp; + } + + /// + /// Determines node subtree cost from existing node properties. + /// + /// Node being parsed. + /// Node subtree cost. + protected override double GetNodeSubtreeCost(Node node) + { + object value = node["PDWAccumulativeCost"] ?? node["EstimatedTotalSubtreeCost"]; + return value != null ? Convert.ToDouble(value, CultureInfo.CurrentCulture) : 0; + } + + /// + /// Updates node special properties such as Operator, Cost, SubtreeCost. + /// + /// Node being parsed. + public override void ParseProperties(object parsedItem, PropertyDescriptorCollection targetPropertyBag, NodeBuilderContext context) + { + base.ParseProperties(parsedItem, targetPropertyBag, context); + + RelOpType item = parsedItem as RelOpType; + Debug.Assert(item != null); + + if (item.RunTimeInformation != null && item.RunTimeInformation.Length > 0) + { + RunTimeCounters actualRowCountCounter = new RunTimeCounters(); + RunTimeCounters actualRowsReadCountCounter = new RunTimeCounters(); + RunTimeCounters actualBatchCountCounter = new RunTimeCounters(); + RunTimeCounters actualRebindsCounter = new RunTimeCounters(); + RunTimeCounters actualRewindsCounter = new RunTimeCounters(); + RunTimeCounters actualExecutionsCounter = new RunTimeCounters(); + RunTimeCounters actualLocallyAggregatedRowsCountCounter = new RunTimeCounters(); + RunTimeCounters actualElapsedTimeCounter = new RunTimeCounters { DisplayTotalCounters = false }; + RunTimeCounters actualElapsedCPUTimeCounter = new RunTimeCounters(); + RunTimeCounters actualScansCounter = new RunTimeCounters(); + RunTimeCounters actualLogicalReadsCounter = new RunTimeCounters(); + RunTimeCounters actualPhysicalReadsCounter = new RunTimeCounters(); + RunTimeCounters actualPageServerReadsCounter = new RunTimeCounters(); + RunTimeCounters actualReadAheadsCounter = new RunTimeCounters(); + RunTimeCounters actualPageServerReadAheadsCounter = new RunTimeCounters(); + RunTimeCounters actualLobLogicalReadsCounter = new RunTimeCounters(); + RunTimeCounters actualLobPhysicalReadsCounter = new RunTimeCounters(); + RunTimeCounters actualLobPageServerReadsCounter = new RunTimeCounters(); + RunTimeCounters actualLobReadAheadsCounter = new RunTimeCounters(); + RunTimeCounters actualLobPageServerReadAheadsCounter = new RunTimeCounters(); + RunTimeCounters actualInputMemoryGrantCounter = new MemGrantRunTimeCounters(); + RunTimeCounters actualOutputMemoryGrantCounter = new MemGrantRunTimeCounters(); + RunTimeCounters actualUsedMemoryGrantCounter = new RunTimeCounters(); + + RunTimeCounters hpcKernelElapsedUsCounter = new RunTimeCounters(); + RunTimeCounters hpcRowCountCounter = new RunTimeCounters(); + RunTimeCounters hpcHostToDeviceBytesCounter = new RunTimeCounters(); + RunTimeCounters hpcDeviceToHostBytesCounter = new RunTimeCounters(); + + ExpandableObjectWrapper actualTimeStatsObjWrapper = new ExpandableObjectWrapper(); + ExpandableObjectWrapper actualIOStatsObjWrapper = new ExpandableObjectWrapper(); + ExpandableObjectWrapper actualMemoryGrantStatsObjWrapper = new ExpandableObjectWrapper(); + + String actualExecutionModeValue = String.Empty; + String actualJoinTypeValue = String.Empty; + bool actualIsInterleavedExecuted = false; + + foreach (RunTimeInformationTypeRunTimeCountersPerThread counter in item.RunTimeInformation) + { + if (counter.BrickIdSpecified) + { + actualRowCountCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualRows); + actualRebindsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualRebinds); + actualRewindsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualRewinds); + actualExecutionsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualExecutions); + actualLocallyAggregatedRowsCountCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualLocallyAggregatedRows); + + if (counter.ActualElapsedmsSpecified) + { + actualElapsedTimeCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualElapsedms); + } + + if (counter.ActualCPUmsSpecified) + { + actualElapsedCPUTimeCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualCPUms); + } + + if (counter.ActualScansSpecified) + { + actualScansCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualScans); + } + + if (counter.ActualLogicalReadsSpecified) + { + actualLogicalReadsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualLogicalReads); + } + + if (counter.ActualPhysicalReadsSpecified) + { + actualPhysicalReadsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualPhysicalReads); + } + + if (counter.ActualPageServerReadsSpecified) + { + actualPageServerReadsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualPageServerReads); + } + + if (counter.ActualReadAheadsSpecified) + { + actualReadAheadsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualReadAheads); + } + + if (counter.ActualPageServerReadAheadsSpecified) + { + actualPageServerReadAheadsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualPageServerReadAheads); + } + + if (counter.ActualLobLogicalReadsSpecified) + { + actualLobLogicalReadsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualLobLogicalReads); + } + + if (counter.ActualLobPhysicalReadsSpecified) + { + actualLobPhysicalReadsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualLobPhysicalReads); + } + + if (counter.ActualLobPageServerReadsSpecified) + { + actualLobPageServerReadsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualLobPageServerReads); + } + + if (counter.ActualLobReadAheadsSpecified) + { + actualLobReadAheadsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualLobReadAheads); + } + + if (counter.ActualLobPageServerReadAheadsSpecified) + { + actualLobPageServerReadAheadsCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualLobPageServerReadAheads); + } + + if (counter.ActualRowsReadSpecified) + { + actualRowsReadCountCounter.AddCounter(counter.Thread, counter.BrickId, counter.ActualRowsRead); + } + + if (counter.BatchesSpecified) + { + actualBatchCountCounter.AddCounter(counter.Thread, counter.BrickId, counter.Batches); + } + + if (counter.HpcRowCountSpecified) + { + hpcRowCountCounter.AddCounter(counter.Thread, counter.BrickId, counter.HpcRowCount); + } + + if (counter.HpcKernelElapsedUsSpecified) + { + hpcKernelElapsedUsCounter.AddCounter(counter.Thread, counter.BrickId, counter.HpcKernelElapsedUs); + } + + if (counter.HpcHostToDeviceBytesSpecified) + { + hpcHostToDeviceBytesCounter.AddCounter(counter.Thread, counter.BrickId, counter.HpcHostToDeviceBytes); + } + + if (counter.HpcDeviceToHostBytesSpecified) + { + hpcDeviceToHostBytesCounter.AddCounter(counter.Thread, counter.BrickId, counter.HpcDeviceToHostBytes); + } + + if (counter.InputMemoryGrantSpecified) + { + actualInputMemoryGrantCounter.AddCounter(counter.Thread, counter.BrickId, counter.InputMemoryGrant); + } + + if (counter.OutputMemoryGrantSpecified) + { + actualOutputMemoryGrantCounter.AddCounter(counter.Thread, counter.BrickId, counter.OutputMemoryGrant); + } + + if (counter.UsedMemoryGrantSpecified) + { + actualUsedMemoryGrantCounter.AddCounter(counter.Thread, counter.BrickId, counter.UsedMemoryGrant); + } + } + else + { + actualRowCountCounter.AddCounter(counter.Thread, counter.ActualRows); + actualRebindsCounter.AddCounter(counter.Thread, counter.ActualRebinds); + actualRewindsCounter.AddCounter(counter.Thread, counter.ActualRewinds); + actualExecutionsCounter.AddCounter(counter.Thread, counter.ActualExecutions); + actualLocallyAggregatedRowsCountCounter.AddCounter(counter.Thread, counter.ActualLocallyAggregatedRows); + + if (counter.ActualElapsedmsSpecified) + { + actualElapsedTimeCounter.AddCounter(counter.Thread, counter.ActualElapsedms); + } + + if (counter.ActualCPUmsSpecified) + { + actualElapsedCPUTimeCounter.AddCounter(counter.Thread, counter.ActualCPUms); + } + + if (counter.ActualScansSpecified) + { + actualScansCounter.AddCounter(counter.Thread, counter.ActualScans); + } + + if (counter.ActualLogicalReadsSpecified) + { + actualLogicalReadsCounter.AddCounter(counter.Thread, counter.ActualLogicalReads); + } + + if (counter.ActualPhysicalReadsSpecified) + { + actualPhysicalReadsCounter.AddCounter(counter.Thread, counter.ActualPhysicalReads); + } + + if (counter.ActualPageServerReadsSpecified) + { + actualPageServerReadsCounter.AddCounter(counter.Thread, counter.ActualPageServerReads); + } + + if (counter.ActualReadAheadsSpecified) + { + actualReadAheadsCounter.AddCounter(counter.Thread, counter.ActualReadAheads); + } + + if (counter.ActualPageServerReadAheadsSpecified) + { + actualPageServerReadAheadsCounter.AddCounter(counter.Thread, counter.ActualPageServerReadAheads); + } + + if (counter.ActualLobLogicalReadsSpecified) + { + actualLobLogicalReadsCounter.AddCounter(counter.Thread, counter.ActualLobLogicalReads); + } + + if (counter.ActualLobPhysicalReadsSpecified) + { + actualLobPhysicalReadsCounter.AddCounter(counter.Thread, counter.ActualLobPhysicalReads); + } + + if (counter.ActualLobPageServerReadsSpecified) + { + actualLobPageServerReadsCounter.AddCounter(counter.Thread, counter.ActualLobPageServerReads); + } + + if (counter.ActualLobReadAheadsSpecified) + { + actualLobReadAheadsCounter.AddCounter(counter.Thread, counter.ActualLobReadAheads); + } + + if (counter.ActualLobPageServerReadAheadsSpecified) + { + actualLobPageServerReadAheadsCounter.AddCounter(counter.Thread, counter.ActualLobPageServerReadAheads); + } + + if (counter.ActualRowsReadSpecified) + { + actualRowsReadCountCounter.AddCounter(counter.Thread, counter.ActualRowsRead); + } + + if (counter.BatchesSpecified) + { + actualBatchCountCounter.AddCounter(counter.Thread, counter.Batches); + } + + if (counter.HpcRowCountSpecified) + { + hpcRowCountCounter.AddCounter(counter.Thread, counter.HpcRowCount); + } + + if (counter.HpcKernelElapsedUsSpecified) + { + hpcKernelElapsedUsCounter.AddCounter(counter.Thread, counter.HpcKernelElapsedUs); + } + + if (counter.HpcHostToDeviceBytesSpecified) + { + hpcHostToDeviceBytesCounter.AddCounter(counter.Thread, counter.HpcHostToDeviceBytes); + } + + if (counter.HpcDeviceToHostBytesSpecified) + { + hpcDeviceToHostBytesCounter.AddCounter(counter.Thread, counter.HpcDeviceToHostBytes); + } + + if (counter.InputMemoryGrantSpecified) + { + actualInputMemoryGrantCounter.AddCounter(counter.Thread, counter.InputMemoryGrant); + } + + if (counter.OutputMemoryGrantSpecified) + { + actualOutputMemoryGrantCounter.AddCounter(counter.Thread, counter.OutputMemoryGrant); + } + + if (counter.UsedMemoryGrantSpecified) + { + actualUsedMemoryGrantCounter.AddCounter(counter.Thread, counter.UsedMemoryGrant); + } + } + + if (counter.ActualExecutions > 0) + { + actualExecutionModeValue = Enum.GetName(typeof(ExecutionModeType), counter.ActualExecutionMode); + } + + if (counter.ActualJoinTypeSpecified) + { + actualJoinTypeValue = Enum.GetName(typeof(PhysicalOpType), counter.ActualJoinType); + } + + if (counter.IsInterleavedExecuted) + { + actualIsInterleavedExecuted = true; + } + } + + if (actualIsInterleavedExecuted) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("IsInterleavedExecuted", actualIsInterleavedExecuted)); + } + + // Create localizable properties and add them to the property bag + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualRows", actualRowCountCounter)); + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualBatches", actualBatchCountCounter)); + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualRebinds", actualRebindsCounter)); + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualRewinds", actualRewindsCounter)); + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualExecutions", actualExecutionsCounter)); + + if (actualRowsReadCountCounter.TotalCounters > 0) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualRowsRead", actualRowsReadCountCounter)); + } + + if (actualLocallyAggregatedRowsCountCounter.TotalCounters > 0) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualLocallyAggregatedRows", actualLocallyAggregatedRowsCountCounter)); + } + + if (hpcRowCountCounter.TotalCounters > 0) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("HpcRowCount", hpcRowCountCounter)); + } + + if (hpcKernelElapsedUsCounter.TotalCounters > 0) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("HpcKernelElapsedUs", hpcKernelElapsedUsCounter)); + } + + if (hpcHostToDeviceBytesCounter.TotalCounters > 0) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("HpcHostToDeviceBytes", hpcHostToDeviceBytesCounter)); + } + + if (hpcDeviceToHostBytesCounter.TotalCounters > 0) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("HpcDeviceToHostBytes", hpcDeviceToHostBytesCounter)); + } + + if (!String.IsNullOrEmpty(actualExecutionModeValue)) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualExecutionMode", actualExecutionModeValue)); + } + + + if (!String.IsNullOrEmpty(actualJoinTypeValue)) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualJoinType", actualJoinTypeValue)); + } + + // Populate the "Actual Time Statistics" property if applicable + // Nested properties include "Actual Elapsed Time" and "Actual Elapsed CPU Time" + if (actualElapsedTimeCounter.NumOfCounters > 0) + { + actualTimeStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualElapsedms", actualElapsedTimeCounter)); + } + + if (actualElapsedCPUTimeCounter.NumOfCounters > 0) + { + actualTimeStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualCPUms", actualElapsedCPUTimeCounter)); + } + + if (actualTimeStatsObjWrapper.Properties.Count > 0) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualTimeStatistics", actualTimeStatsObjWrapper)); + } + + // Populate the "Actual IO Statistics" property if applicable + // Nested properties include "Scan" and "Read" properties. + if (actualScansCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualScans", actualScansCounter)); + } + + if (actualLogicalReadsCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualLogicalReads", actualLogicalReadsCounter)); + } + + if (actualPhysicalReadsCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualPhysicalReads", actualPhysicalReadsCounter)); + } + + if (actualPageServerReadsCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualPageServerReads", actualPageServerReadsCounter)); + } + + if (actualReadAheadsCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualReadAheads", actualReadAheadsCounter)); + } + + if (actualPageServerReadAheadsCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualPageServerReadAheads", actualPageServerReadAheadsCounter)); + } + + if (actualLobLogicalReadsCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualLobLogicalReads", actualLobLogicalReadsCounter)); + } + + if (actualLobPhysicalReadsCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualLobPhysicalReads", actualLobPhysicalReadsCounter)); + } + + if (actualLobPageServerReadsCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualLobPageServerReads", actualLobPageServerReadsCounter)); + } + + if (actualLobReadAheadsCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualLobReadAheads", actualLobReadAheadsCounter)); + } + + if (actualLobPageServerReadAheadsCounter.NumOfCounters > 0) + { + actualIOStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("ActualLobPageServerReadAheads", actualLobPageServerReadAheadsCounter)); + } + + if (actualIOStatsObjWrapper.Properties.Count > 0) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualIOStatistics", actualIOStatsObjWrapper)); + } + + // Populate ActualMemoryGrantStats + if (actualInputMemoryGrantCounter.NumOfCounters > 0) + { + actualMemoryGrantStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("InputMemoryGrant", actualInputMemoryGrantCounter)); + } + + if (actualOutputMemoryGrantCounter.NumOfCounters > 0) + { + actualMemoryGrantStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("OutputMemoryGrant", actualOutputMemoryGrantCounter)); + } + + if (actualUsedMemoryGrantCounter.NumOfCounters > 0) + { + actualMemoryGrantStatsObjWrapper.Properties.Add(PropertyFactory.CreateProperty("UsedMemoryGrant", actualUsedMemoryGrantCounter)); + } + + if (actualMemoryGrantStatsObjWrapper.Properties.Count > 0) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("ActualMemoryGrantStats", actualMemoryGrantStatsObjWrapper)); + } + } + + // Decompose RunTimePartitionSummary and add them individually. + // Otherwise, the properties will show up as nested in the property window. + if (item.RunTimePartitionSummary != null && item.RunTimePartitionSummary.PartitionsAccessed != null) + { + RunTimePartitionSummaryTypePartitionsAccessed partitions = item.RunTimePartitionSummary.PartitionsAccessed; + + // Create localizable properties and add them to the property bag + targetPropertyBag.Add(PropertyFactory.CreateProperty("PartitionCount", partitions.PartitionCount)); + + if (partitions.PartitionRange != null && partitions.PartitionRange.Length > 0) + { + targetPropertyBag.Add(PropertyFactory.CreateProperty("PartitionsAccessed", GetPartitionRangeString(partitions.PartitionRange))); + } + } + } + + + /// + /// Helper method to format partition range string. + /// + /// Partition ranges + /// property string + private static string GetPartitionRangeString(RunTimePartitionSummaryTypePartitionsAccessedPartitionRange[] ranges) + { + Debug.Assert(ranges != null); + StringBuilder stringBuilder = new StringBuilder(); + string separator = CultureInfo.CurrentCulture.TextInfo.ListSeparator; + for (int i = 0; i < ranges.Length; i++) + { + if (i != 0) + { + stringBuilder.Append(separator); + } + + RunTimePartitionSummaryTypePartitionsAccessedPartitionRange range = ranges[i]; + if (range.Start == range.End) + { + // The range is a single number + stringBuilder.Append(range.Start); + } + else + { + stringBuilder.AppendFormat(CultureInfo.CurrentCulture, "{0}..{1}", range.Start, range.End); + } + } + return stringBuilder.ToString(); + } + + /// + /// Private constructor prevents this object from being externally instantiated + /// + private RelOpTypeParser() + { + } + + /// + /// Singelton instance + /// + private static RelOpTypeParser relOpTypeParser = null; + public static RelOpTypeParser Instance + { + get + { + if (relOpTypeParser == null) + { + relOpTypeParser = new RelOpTypeParser(); + } + return relOpTypeParser; + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/RunTimeCounters.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/RunTimeCounters.cs new file mode 100644 index 00000000..a305e242 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/RunTimeCounters.cs @@ -0,0 +1,269 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Globalization; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// RunTimeCounters class stores RunTimeCountersPerThread information + /// + [TypeConverterAttribute(typeof(ExpandableObjectConverter))] + internal class RunTimeCounters : ICustomTypeDescriptor + { + #region Inner classes + + protected struct Counter + { + public int Thread; + public int BrickId; + public bool BrickIdSpecified; + public ulong Value; + + public Counter(int thread, ulong value) + { + Thread = thread; + BrickIdSpecified = false; + BrickId = 0; + Value = value; + } + + public Counter(int thread, int brickId, ulong value) + { + Thread = thread; + BrickIdSpecified = true; + BrickId = brickId; + Value = value; + } + } + + #endregion + + #region Fields + + ulong totalCounters; + ulong maxCounter; + protected List counters = new List(); + + #endregion + + #region Constructors + + public RunTimeCounters() + { + maxCounter = 0; + DisplayTotalCounters = true; + } + + #endregion + + #region Public methods and properties + + public void AddCounter(int thread, ulong counterValue) + { + this.counters.Add(new Counter(thread, counterValue)); + this.totalCounters += counterValue; + if (counterValue > maxCounter) + { + maxCounter = counterValue; + } + } + + public void AddCounter(int thread, int brickId, ulong counterValue) + { + this.counters.Add(new Counter(thread, brickId, counterValue)); + this.totalCounters += counterValue; + if (counterValue > maxCounter) + { + maxCounter = counterValue; + } + } + + /// + /// sum of values passed to AddCounter + /// + public ulong TotalCounters + { + get { return this.totalCounters; } + } + + /// + /// max value passed to AddCounter + /// + public ulong MaxCounter + { + get { return this.maxCounter; } + } + + /// + /// if true, display TotalCounters as string representation, otherwise display MaxCounter + /// + public bool DisplayTotalCounters + { + get; set; + } + + /// + /// Returns the number of Counter objects added to counters list + /// Does not represent the calculated total count. + /// + public int NumOfCounters + { + get { return this.counters.Count; } + } + + /// + /// string representation of RunTimeCounters + /// + public override string ToString() + { + // display max counter value as the string representation of this class for specific properties, for ex ActualElapsedms + // for other properties, display total counter value + if (DisplayTotalCounters) + { + return TotalCounters.ToString(CultureInfo.CurrentCulture); + } + else + { + return MaxCounter.ToString(CultureInfo.CurrentCulture); + } + } + + #endregion + + #region ICustomTypeDescriptor + + AttributeCollection ICustomTypeDescriptor.GetAttributes() + { + return TypeDescriptor.GetAttributes(GetType()); + } + + EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() + { + return TypeDescriptor.GetDefaultEvent(GetType()); + } + + PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() + { + return TypeDescriptor.GetDefaultProperty(GetType()); + } + + object ICustomTypeDescriptor.GetEditor(Type editorBaseType) + { + return TypeDescriptor.GetEditor(GetType(), editorBaseType); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents() + { + return TypeDescriptor.GetEvents(GetType()); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) + { + return TypeDescriptor.GetEvents(GetType(), attributes ); + } + + object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor propertyDescriptor) + { + return this; + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() + { + PropertyDescriptor[] propertiesDescriptors = new PropertyDescriptor[this.counters.Count]; + string description = SR.Keys.PerThreadCounterDescription; + + if (this.counters.Count == 1) + { + PropertyValue property; + if (this.counters[0].BrickIdSpecified) + { + property = new PropertyValue(SR.RuntimeCounterThreadOnInstance(this.counters[0].Thread, this.counters[0].BrickId), this.counters[0].Value); + } + else + { + property = new PropertyValue(SR.RuntimeCounterThreadAll, this.counters[0].Value); + } + property.SetDisplayNameAndDescription(property.Name, description); + propertiesDescriptors[0] = property; + } + else + { + for (int i=0; i + /// derived class that overrides ToString for memory grant related properties + /// + [TypeConverterAttribute(typeof(ExpandableObjectConverter))] + internal class MemGrantRunTimeCounters : RunTimeCounters + { + /// + /// string representation of MemGrantRunTimeCounters + /// + public override string ToString() + { + ulong displayValue = this.TotalCounters; + + // if there is more than one thread/counter, memory grant from thread 0 is not used so it doesn't carry meaningful counter value and needs to ignored + if (this.NumOfCounters > 1) + { + // find thread 0 counter value, note it may not be the first element in counters list + foreach (var ct in this.counters) + { + if (ct.Thread == 0) + { + displayValue -= ct.Value; + break; + } + } + } + + return displayValue.ToString(CultureInfo.CurrentCulture); + } + } +} \ No newline at end of file diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/StatementParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/StatementParser.cs new file mode 100644 index 00000000..36da3211 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/StatementParser.cs @@ -0,0 +1,144 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections.Generic; +using System.Globalization; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Parses stytement type ShowPlan XML nodes + /// + internal class StatementParser : XmlPlanParser + { + /// + /// Creates new node and adds it to the graph. + /// + /// Item being parsed. + /// Parent item. + /// Parent node. + /// Node builder context. + /// The node that corresponds to the item being parsed. + public override Node GetCurrentNode(object item, object parentItem, Node parentNode, NodeBuilderContext context) + { + return NewNode(context); + } + + /// + /// Determines Operation that corresponds to the object being parsed. + /// + /// Node being parsed. + /// Operation that corresponds to the node. + protected override Operation GetNodeOperation(Node node) + { + object statementType = node["StatementType"]; + Operation statement = statementType != null + ? OperationTable.GetStatement(statementType.ToString()) + : Operation.Unknown; + + + return statement; + } + + /// + /// Determines node subtree cost from existing node properties. + /// + /// Node being parsed. + /// Node subtree cost. + protected override double GetNodeSubtreeCost(Node node) + { + object value = node["StatementSubTreeCost"]; + return value != null ? Convert.ToDouble(value, CultureInfo.CurrentCulture) : 0; + } + + protected override bool ShouldParseItem(object parsedItem) + { + // Special case. An empty statement without QueryPlan but with + // a UDF or StoreProc should be skipped + StmtSimpleType statement = parsedItem as StmtSimpleType; + if (statement != null) + { + // We use hidden wrapper statements for UDFs and StoredProcs + // Hidden statements don't have any of their properties defined + // We can use one of properties which is always set by server + // such as StatementIdSpecified to distinguish between a real + // statement and a hidden wrapper statement + if (!statement.StatementIdSpecified) + { + return false; + } + } + + // By default, the statement is parsed + return true; + } + + /// + /// Enumerates FunctionType blocks and removes all items from UDF and StoredProc properties. + /// + /// The item being parsed. + /// Enumeration. + public override IEnumerable ExtractFunctions(object parsedItem) + { + StmtSimpleType statement = parsedItem as StmtSimpleType; + if (statement != null) + { + // If this is a simple statement it may have UDF and StoredProc fields + if (statement.UDF != null) + { + foreach (FunctionType function in statement.UDF) + { + yield return new FunctionTypeItem(function, FunctionTypeItem.ItemType.Udf); + } + statement.UDF = null; + } + + if (statement.StoredProc != null) + { + yield return new FunctionTypeItem(statement.StoredProc, FunctionTypeItem.ItemType.StoredProcedure); + statement.StoredProc = null; + } + } + else + { + // This is some other type of Statement. Call ExtractFunctions for all its children + foreach (object item in GetChildren(parsedItem)) + { + XmlPlanParser parser = XmlPlanParserFactory.GetParser(item.GetType()); + foreach (FunctionTypeItem functionItem in parser.ExtractFunctions(item)) + { + yield return functionItem; + } + } + } + + yield break; + } + + /// + /// protected constructor prevents this object from being externally instantiated + /// + protected StatementParser() + { + } + + /// + /// Singelton instance + /// + private static StatementParser statementParser = null; + public static StatementParser Instance + { + get + { + if (statementParser == null) + { + statementParser = new StatementParser(); + } + return statementParser; + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanHierarchyParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanHierarchyParser.cs new file mode 100644 index 00000000..91c4d4d5 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanHierarchyParser.cs @@ -0,0 +1,67 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System.Collections.Generic; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + internal class XmlPlanHierarchyParser : XmlPlanParser + { + /// + /// This function doesn't do anything. It simply returns the parent node + /// passed it. + /// + /// Item being parsed. + /// Parent item. + /// Parent node. + /// Node builder context. + /// The node that corresponds to the item being parsed. + public override Node GetCurrentNode(object item, object parentItem, Node parentNode, NodeBuilderContext context) + { + return parentNode; + } + + /// + /// Extracts FunctionType blocks. + /// + /// The item being parsed. + /// Enumeration. + public override IEnumerable ExtractFunctions(object parsedItem) + { + // Recursively call ExtractFunctions for each children. + foreach (object item in GetChildren(parsedItem)) + { + XmlPlanParser parser = XmlPlanParserFactory.GetParser(item.GetType()); + foreach (FunctionTypeItem functionItem in parser.ExtractFunctions(item)) + { + yield return functionItem; + } + } + } + + /// + /// Private constructor prevents this object from being externally instantiated + /// + protected XmlPlanHierarchyParser() + { + } + + /// + /// Singelton instance + /// + private static XmlPlanHierarchyParser xmlPlanHierarchyParser = null; + public static XmlPlanHierarchyParser Instance + { + get + { + if (xmlPlanHierarchyParser == null) + { + xmlPlanHierarchyParser = new XmlPlanHierarchyParser(); + } + return xmlPlanHierarchyParser; + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanNodeBuilder.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanNodeBuilder.cs new file mode 100644 index 00000000..68969e85 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanNodeBuilder.cs @@ -0,0 +1,385 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; +using System.IO; +using System.Xml; +using System.Text; +using System.Xml.Serialization; +using System.Reflection; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Builds hierarchy of Graph objects from ShowPlan XML + /// + internal sealed class XmlPlanNodeBuilder : INodeBuilder, IXmlBatchParser + { + #region Constructor + + public XmlPlanNodeBuilder(ShowPlanType showPlanType) + { + this.showPlanType = showPlanType; + } + + #endregion + + #region INodeBuilder + + /// + /// Builds one or more Graphs that + /// represnet data from the data source. + /// + /// Data Source. + /// An array of AnalysisServices Graph objects. + public ShowPlanGraph[] Execute(object dataSource) + { + ShowPlanXML plan = dataSource as ShowPlanXML; + if (plan == null) + { + plan = ReadXmlShowPlan(dataSource); + } + + List graphs = new List(); + + foreach (BaseStmtInfoType statement in EnumStatements(plan)) + { + // Reset currentNodeId (used through Context) and create new context + this.currentNodeId = 0; + NodeBuilderContext context = new NodeBuilderContext(new ShowPlanGraph(), this.showPlanType, this); + // Parse the statement block + XmlPlanParser.Parse(statement, null, null, context); + // Add graph to the list + graphs.Add(context.Graph); + } + + return graphs.ToArray(); + } + + #endregion + + #region IXmlBatchParser + + /// + /// Returns an XML string for a specific ShowPlan statement. + /// This is used to save a plan corresponding to a particular graph control. + /// + /// Data source that contains the full plan. + /// Statement index. + /// XML string that contains execution plan for the specified statement index. + public string GetSingleStatementXml(object dataSource, int statementIndex) + { + StmtBlockType newStatementBlock = GetSingleStatementObject(dataSource, statementIndex); + + // Now make the new plan based on the existing one that contains only one statement. + ShowPlanXML plan = ReadXmlShowPlan(dataSource); + plan.BatchSequence = new StmtBlockType[][] + { + new StmtBlockType[] { newStatementBlock } + }; + + // Serialize the new plan. + StringBuilder stringBuilder = new StringBuilder(); + Serializer.Serialize(new StringWriter(stringBuilder), plan); + + return stringBuilder.ToString(); + } + + /// + /// Returns single statement block type object + /// + /// Data source + /// Statement index in the data source + /// Single statement block type object + public StmtBlockType GetSingleStatementObject(object dataSource, int statementIndex) + { + // First read the whole plan from the data source + ShowPlanXML plan = ReadXmlShowPlan(dataSource); + + int index = 0; + StmtBlockType newStatementBlock = new StmtBlockType(); + + // Locate the statement for the specified index + foreach (BaseStmtInfoType statement in EnumStatements(plan)) + { + if (statementIndex == index++) + { + // This is the statement we are looking for + newStatementBlock.Items = new BaseStmtInfoType[] { statement }; + break; + } + } + + if (newStatementBlock.Items == null) + { + throw new ArgumentOutOfRangeException("statementIndex"); + } + + return newStatementBlock; + } + + #endregion + + #region Internal properties + + /// + /// Gets current node Id and internally increments the Id. + /// + /// ID. + internal int GetCurrentNodeId() + { + return ++currentNodeId; + } + + #endregion + + + #region Implementation details + + /// + /// Deserializes XML ShowPlan from the data source + /// + /// Data Source + /// ShowPlanXML object which is the root of deserialized plan. + private ShowPlanXML ReadXmlShowPlan(object dataSource) + { + ShowPlanXML result = null; + + string stringData = dataSource as string; + if (stringData != null) + { + using (StringReader reader = new StringReader(stringData)) + { + result = Serializer.Deserialize(reader) as ShowPlanXML; + } + } + else + { + byte[] binaryData = dataSource as byte[]; + if (binaryData != null) + { + using (MemoryStream stream = new MemoryStream(binaryData)) + { + // We need to use reflection to obtain private method of XmlReader class + // that can create a binary reader. Public XmlReader.Create does not + // support this. + MethodInfo createSqlReaderMethodInfo = typeof(System.Xml.XmlReader).GetMethod("CreateSqlReader", BindingFlags.Static | BindingFlags.NonPublic); + object[] args = new object[3] { stream, null, null }; + + using (XmlReader reader = (XmlReader)createSqlReaderMethodInfo.Invoke(null, args)) + { + result = Serializer.Deserialize(reader) as ShowPlanXML; + } + } + } + } + + if (null == result) + { + Debug.Assert(false, "Unexpected ShowPlan source = " + dataSource.GetType().ToString()); + throw new ArgumentException(SR.Keys.UnknownShowPlanSource); + } + + return result; + } + + /// + /// Enumerates statements in XML ShowPlan. This also looks inside each statement and + /// enumerates sub-statements found in FunctionType blocks. + /// + /// XML ShowPlan. + /// Statements enumerator. + private IEnumerable EnumStatements(ShowPlanXML plan) + { + foreach (StmtBlockType[] statementBatch in plan.BatchSequence) + { + foreach (StmtBlockType statementBlock in statementBatch) + { + ExtractFunctions(statementBlock); + + // flatten out any statements contained within then / else clauses to make it appear as though all code paths are + // executed sequentially, this is useful for the Live show plan case because it only displays a single show-plan instance at any given time. + if (showPlanType == ShowPlanType.Live) + { + FlattenConditionClauses(statementBlock); + } + + foreach (BaseStmtInfoType statement in EnumStatements(statementBlock)) + { + yield return statement; + } + } + } + } + + /// + /// We do some special handling of the showplan graphs to flatten out control nodes. See VSTS 3657984. + /// Essentially the problem is that the Actual showplan and the predicted show plan are treated differently. + /// The predicted show plan shows the control node (while, if-then-else) when the actual show plans only contain a single + /// plan per statement. This difference makes it difficult to match up the running query against the predicted showplan. Further + /// complicating the situation is that each statement may re-use nodeIDs which violates a fundamental assumption + /// of the LQS tool and the progress estimators. We can work-around this by flattening out the predicted show plan graph + /// to look as a series of statements without the control structures or nesting + /// + private void FlattenConditionClauses(StmtBlockType statementBlock) + { + if (statementBlock != null && statementBlock.Items != null) + { + ArrayList targetStatementList = new ArrayList(); + + foreach (BaseStmtInfoType statement in statementBlock.Items) + { + targetStatementList.Add(statement); + + FlattenConditionClauses(statement, targetStatementList); + } + + // Make a new Items array for the statement block by combining existing items and + // new wrapper statements + statementBlock.Items = new BaseStmtInfoType[targetStatementList.Count]; + targetStatementList.CopyTo(statementBlock.Items); + } + } + + private void FlattenConditionClauses(BaseStmtInfoType statement, ArrayList targetStatementList) + { + // Enum statement children and genetate wrapper statements for them + XmlPlanParser parser = XmlPlanParserFactory.GetParser(statement.GetType()); + foreach (object child in parser.GetChildren(statement)) + { + StmtCondTypeThen stmtThen = child as StmtCondTypeThen; + if (stmtThen != null) + { + //add this element and its children + if (stmtThen.Statements != null && stmtThen.Statements.Items != null) + { + foreach (BaseStmtInfoType subStatement in stmtThen.Statements.Items) + { + targetStatementList.Add(subStatement); + FlattenConditionClauses(subStatement, targetStatementList); + } + } + } + + else + { + StmtCondTypeElse stmtElse = child as StmtCondTypeElse; + if (stmtElse != null) + { + //add this element and its children + if (stmtElse.Statements != null && stmtElse.Statements.Items != null) + { + foreach (BaseStmtInfoType subStatement in stmtElse.Statements.Items) + { + targetStatementList.Add(subStatement); + FlattenConditionClauses(subStatement, targetStatementList); + } + } + } + } + } + } + + /// + /// Extracts UDF and StoredProc items and places each of them at the top level + /// wrapping each of them with an empty statement. + /// + /// Statement block + private void ExtractFunctions(StmtBlockType statementBlock) + { + if (statementBlock != null && statementBlock.Items != null) + { + ArrayList targetStatementList = new ArrayList(); + + foreach (BaseStmtInfoType statement in statementBlock.Items) + { + targetStatementList.Add(statement); + + ExtractFunctions(statement, targetStatementList); + } + + // Make a new Items array for the statement block by combining existing items and + // new wrapper statements + statementBlock.Items = new BaseStmtInfoType[targetStatementList.Count]; + targetStatementList.CopyTo(statementBlock.Items); + } + } + + /// + /// Extracts UDF and StoredProc items from a statement and adds them to a target list. + /// + /// Statement. + /// Target list to add a newly generated statement to. + private void ExtractFunctions(BaseStmtInfoType statement, ArrayList targetStatementList) + { + // Enum FunctionType objects and generate wrapper statements for them + XmlPlanParser parser = XmlPlanParserFactory.GetParser(statement.GetType()); + foreach (FunctionTypeItem functionItem in parser.ExtractFunctions(statement)) + { + StmtSimpleType subStatement = null; + + if (functionItem.Type == FunctionTypeItem.ItemType.StoredProcedure) + { + subStatement = new StmtSimpleType(); + subStatement.StoredProc = functionItem.Function; + } + else if (functionItem.Type == FunctionTypeItem.ItemType.Udf) + { + subStatement = new StmtSimpleType(); + subStatement.UDF = new FunctionType[] { functionItem.Function }; + } + else + { + Debug.Assert(false, "Ivalid function type"); + } + + if (subStatement != null) + { + targetStatementList.Add(subStatement); + + // Call itself recursively. + if (functionItem.Function.Statements != null && functionItem.Function.Statements.Items != null) + { + foreach (BaseStmtInfoType functionStatement in functionItem.Function.Statements.Items) + { + ExtractFunctions(functionStatement, targetStatementList); + } + } + } + } + } + + /// + /// Recursively enumerates statements in StmtBlockType. + /// + /// Statement block (may contain multiple statements). + /// Statement enumerator. + private IEnumerable EnumStatements(StmtBlockType statementBlock) + { + if (statementBlock != null && statementBlock.Items != null) + { + foreach (BaseStmtInfoType statement in statementBlock.Items) + { + yield return statement; + } + } + } + + #endregion + + #region Private members + + private static readonly XmlSerializer Serializer = new XmlSerializer(typeof(ShowPlanXML)); + + private ShowPlanType showPlanType; + private int currentNodeId; + + #endregion + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanParser.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanParser.cs new file mode 100644 index 00000000..7c34ecf4 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanParser.cs @@ -0,0 +1,284 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Class for enumerating FunctionType objects + /// + internal sealed class FunctionTypeItem + { + internal enum ItemType + { + Unknown, + Udf, + StoredProcedure + }; + + internal FunctionTypeItem(FunctionType function, ItemType type) + { + this.function = function; + this.type = type; + } + + internal FunctionType Function + { + get { return this.function; } + } + + internal ItemType Type + { + get { return this.type; } + } + + private FunctionType function; + private ItemType type; + } + + /// + /// Base class for all Xml Execution plan node parsers. + /// + internal abstract class XmlPlanParser : ObjectParser + { + /// + /// Parses a ShowPlan item and either creates a new Node or adds properties to + /// the provided Node. + /// + /// Item being parsed. + /// Existing node which is used as a property host or a parent for the new node. + /// Node builder context. + public static void Parse(object item, object parentItem, Node parentNode, NodeBuilderContext context) + { + XmlPlanParser parser = XmlPlanParserFactory.GetParser(item.GetType()); + + if (parser != null) + { + Node node = null; + + if (parser.ShouldParseItem(item)) + { + node = parser.GetCurrentNode(item, parentItem, parentNode, context); + if (node != null) + { + // add node/statement mapping to the ShowPlanGraph + if (context != null && context.Graph != null && !context.Graph.NodeStmtMap.ContainsKey(node)) + { + context.Graph.NodeStmtMap.Add(node, item); + } + parser.ParseProperties(item, node.Properties, context); + } + if(parentNode == null) + { + context.Graph.Root = node; + } + } + else + { + node = parentNode; + } + + foreach (object child in parser.GetChildren(item)) + { + XmlPlanParser.Parse(child, item, node, context); + } + + if (node != parentNode) + { + parser.SetNodeSpecialProperties(node); + if (parentNode != null) + { + parentNode.AddChild(node); + } + } + } + else + { + Debug.Assert(false, "Unexpected run type = " + item.ToString()); + // Debug.LogExThrow(); {{removed from ssms}} + throw new InvalidOperationException(SR.Keys.UnexpectedRunType); + } + } + + /// + /// + /// + /// + /// + /// + /// + /// + public abstract Node GetCurrentNode(object item, object parentItem, Node parentNode, NodeBuilderContext context); + + /// + /// Enumerates children items of the item being parsed. + /// + /// The item being parsed. + /// Enumeration. + public virtual IEnumerable GetChildren(object parsedItem) + { + return EnumerateChildren(parsedItem); + } + + /// + /// Extracts FunctionType blocks. + /// + /// The item being parsed. + /// Enumeration. + public virtual IEnumerable ExtractFunctions(object parsedItem) + { + // By default - no functions + yield break; + } + + /// + /// Determines whether this node should be parsed + /// + /// ShowPlan item + /// + protected virtual bool ShouldParseItem(object parsedItem) + { + // All items are parsed by default + return true; + } + + /// + /// Updates node special properties such as Operator, Cost, SubtreeCost. + /// + /// Node being parsed. + protected virtual void SetNodeSpecialProperties(Node node) + { + if (node.Operation == null) + { + node.Operation = GetNodeOperation(node); + } + + // Retrieve Subtree cost for this node + node.SubtreeCost = GetNodeSubtreeCost(node); + + // EstimateExecutions = EstimateRebinds + EstimateRewinds + 1 + if (node["EstimateRebinds"] != null && node["EstimateRewinds"] != null) + { + double estimateRebinds = (double) node["EstimateRebinds"]; + double estimateRewinds = (double) node["EstimateRewinds"]; + node["EstimateExecutions"] = estimateRebinds + estimateRewinds + 1; + } + + // EstimateRowsAllExecs = EstimateRows * EstimateExecutions + double estimateRows = node["EstimateRows"] == null ? 0.0 : Convert.ToDouble(node["EstimateRows"]); + double estimateExecutions = node["EstimateExecutions"] == null ? 0.0 : Convert.ToDouble(node["EstimateExecutions"]); + double actualExecutions = node["ActualExecutions"] == null ? 0.0 : ((RunTimeCounters)node["ActualExecutions"]).TotalCounters; + + //It's unlikely the total number of rows would exceed DBL_MAX = 1.8*(10^308), thus safe to not check overflow. + node["EstimateRowsAllExecs"] = estimateRows * estimateExecutions; + } + + /// + /// Determines if the current property is used to reference a child item. + /// Hierarchy properties are skipped when property wrappers are being created. + /// + /// Property subject to test. + /// True if the property is a hierarchy property; + /// false if this is a regular property that should appear in the property grid. + /// + protected override bool ShouldSkipProperty(PropertyDescriptor property) + { + Type type = property.PropertyType; + + if (type.IsArray) + { + type = type.GetElementType(); + } + + return XmlPlanParserFactory.GetParser(type) != null; + } + + /// + /// Determines Operation that corresponds to the object being parsed. + /// + /// Node being parsed. + /// Operation that corresponds to the node. + protected virtual Operation GetNodeOperation(Node node) + { + // STrace.Assert(false, "GetNodeOperation should not be called on base class."); {{aasim useless edit}} + // STrace.LogExThrow(); {{aasim useless edit}} + throw new InvalidOperationException(); + } + + /// + /// Determines node subtree cost from existing node properties. + /// + /// Node being parsed. + /// Node subtree cost. + protected virtual double GetNodeSubtreeCost(Node node) + { + // STrace.Assert(false, "GetNodeSubtreeCost should not be called because it isn't defined for all node types"); {{aasim useless edit}} + // STrace.LogExThrow(); {{aasim useless edit}} + throw new InvalidOperationException(); + } + + /// + /// This method gets children in a generic way. + /// It should be avoided in the cases where performance matters. + /// + /// Item to enumerate children for + /// Enumeration of children + public static IEnumerable EnumerateChildren(object parsedItem) + { + foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(parsedItem)) + { + if (Type.GetTypeCode(property.PropertyType) == TypeCode.Object) + { + object value = property.GetValue(parsedItem); + if (value == null) + { + continue; + } + + if (value is IEnumerable) + { + foreach (object item in (IEnumerable)value) + { + if (XmlPlanParserFactory.GetParser(item.GetType()) != null) + { + yield return item; + } + } + } + else + { + if (XmlPlanParserFactory.GetParser(value.GetType()) != null) + { + yield return value; + } + } + } + } + + yield break; + } + + /// + /// Creates a new Node. + /// + /// NodeBuilderContext. + /// New node instance. + public static Node NewNode(NodeBuilderContext context) + { + XmlPlanNodeBuilder nodeBuilder = context.Context as XmlPlanNodeBuilder; + Debug.Assert(nodeBuilder != null); + + // We don't use "NodeId" property of the Node here because + // not all nodes have Id and the same Id can repeat in different + // statement branches + return new Node(nodeBuilder.GetCurrentNodeId(), context); + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanParserFactory.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanParserFactory.cs new file mode 100644 index 00000000..7c5d7b2d --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/XmlPlanParserFactory.cs @@ -0,0 +1,67 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + internal static class XmlPlanParserFactory + { + public static XmlPlanParser GetParser(Type type) + { + while (true) + { + switch (type.Name) + { + case "RelOpType": + return RelOpTypeParser.Instance; + + case "BaseStmtInfoType": + return StatementParser.Instance; + + case "RelOpBaseType": + return RelOpBaseTypeParser.Instance; + + case "FilterType": + return FilterTypeParser.Instance; + + case "MergeType": + return MergeTypeParser.Instance; + + case "StmtCursorType": + return CursorStatementParser.Instance; + + case "CursorPlanTypeOperation": + return CursorOperationParser.Instance; + + case "StmtBlockType": + case "QueryPlanType": + case "CursorPlanType": + case "ReceivePlanTypeOperation": + case "StmtCondTypeThen": + case "StmtCondTypeElse": + return XmlPlanHierarchyParser.Instance; + + case "StmtCondTypeCondition": + return ConditionParser.Instance; + + case "FunctionType": + return FunctionTypeParser.Instance; + + case "IndexScanType": + case "CreateIndexType": + return IndexOpTypeParser.Instance; + + case "Object": + return null; + + default: + type = type.BaseType; + break; + } + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/nodebuilderconstants.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/nodebuilderconstants.cs new file mode 100644 index 00000000..6eecced4 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/nodebuilderconstants.cs @@ -0,0 +1,67 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// A class that lists String constants common to XML Show Plan Node Parsing + /// + public sealed class NodeBuilderConstants + { + public static readonly string ActualExecutions = "ActualExecutions"; + public static readonly string ActualRows = "ActualRows"; + public static readonly string Argument = "Argument"; + public static readonly string AvgRowSize = "AvgRowSize"; + public static readonly string DefinedValues = "DefinedValues"; + public static readonly string ElapsedTime = "ElapsedTime"; + public static readonly string EstimateCPU = "EstimateCPU"; + public static readonly string EstimateExecutions = "EstimateExecutions"; + public static readonly string EstimateIO = "EstimateIO"; + public static readonly string EstimateRows = "EstimateRows"; + public static readonly string LogicalOp = "LogicalOp"; + public static readonly string NodeId = "NodeId"; + public static readonly string OutputList = "OutputList"; + public static readonly string Parallel = "Parallel"; + public static readonly string ParameterCompiledValue = "ParameterCompiledValue"; + public static readonly string ParameterList = "ParameterList"; + public static readonly string ParameterRuntimeValue = "ParameterRuntimeValue"; + public static readonly string PhysicalOp = "PhysicalOp"; + public static readonly string SeekPredicate = "SeekPredicate"; + public static readonly string SeekPredicates = "SeekPredicates"; + public static readonly string StatementText = "StatementText"; + public static readonly string StatementType = "StatementType"; + public static readonly string TotalSubtreeCost = "TotalSubtreeCost"; + public static readonly string Warnings = "Warnings"; + + public static readonly string Database = "Database"; + public static readonly string Table = "Table"; + public static readonly string Schema = "Schema"; + public static readonly string Predicate = "Predicate"; + public static readonly string Storage = "Storage"; + public static readonly string Index = "Index"; + public static readonly string Object = "Object"; + + //constants for Live Nodes + public static readonly string Status = "Status"; + public static readonly string OpenTime = "OpenTime"; + public static readonly string CompletionEstimate = "CompletionEstimate"; + public static readonly string CloseTime = "CloseTime"; + + //constants for ShowPlan Comparison + public static readonly string SkeletonNode = "SkeletonNode"; + public static readonly string SkeletonHasMatch = "SkeletonHasMatch"; + } + + /// + /// ShowPlan type + /// + public enum ShowPlanType + { + Unknown, + Actual, + Estimated, + Live + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/showplangraph.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/showplangraph.cs new file mode 100644 index 00000000..16d73e90 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/showplangraph.cs @@ -0,0 +1,108 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections.Generic; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph +{ + /// + /// Extension of graph with some handy included methods specific for ShowPlan use + /// + public class ShowPlanGraph : Graph + { + private Dictionary nodeStmtMap = new Dictionary(); + + public Dictionary NodeStmtMap + { + get { return this.nodeStmtMap; } + } + + /// + /// Gets the SQL Statement for this graph. + /// + public string Statement + { + get + { + // Special case: in the case of UDF or SP graphs thr root node doesn't + // have StatementText. We should use Procedure Name instead + return RootNode["StatementText"] as string ?? RootNode["ProcName"] as string ?? ""; + } + } + + /// + /// The StatementId as recorded in the RootNode for this graph, -1 if not available + /// + public int StatementId + { + get + { + return PullIntFromRoot("StatementId"); + } + } + + /// + /// The StatementCompId as recorded in the RootNode for this graph, -1 if not available + /// + public int StatementCompId + { + get + { + return PullIntFromRoot("StatementCompId"); + } + } + + /// + /// The QueryPlanHash as recorded in the RootNode for this graph, null if not available + /// + public string QueryPlanHash + { + get + { + return RootNode["QueryPlanHash"] as string; + } + } + + internal Node RootNode + { + get + { + return this.Root; + } + } + + /// + /// Helper method to parse an XMLString and return the set of ShowPlan graphs for it + /// + /// + /// + public static ShowPlanGraph[] ParseShowPlanXML(object showPlan, ShowPlanType type = ShowPlanType.Unknown) + { + // Create a builder compatible with the data source + INodeBuilder nodeBuilder = NodeBuilderFactory.Create(showPlan, type); + + // Parse showplan data + return nodeBuilder.Execute(showPlan); + } + + private int PullIntFromRoot(string name) + { + string statementId = RootNode[name].ToString(); + + if (statementId != null) + { + int id; + if (Int32.TryParse(statementId, out id)) + { + return id; + } + } + + //error condition, return -1 + return -1; + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/showplanxml.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/showplanxml.cs new file mode 100644 index 00000000..e8d4427d --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/showplanxml.cs @@ -0,0 +1,13136 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +// +// This source code was auto-generated by xsd, Version=4.8.3928.0. +// +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph { + using System.Xml.Serialization; + + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + [System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan", IsNullable=false)] + public partial class ShowPlanXML { + + private StmtBlockType[][] batchSequenceField; + + private string versionField; + + private string buildField; + + private bool clusteredModeField; + + private bool clusteredModeFieldSpecified; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Batch", IsNullable=false)] + [System.Xml.Serialization.XmlArrayItemAttribute("Statements", IsNullable=false, NestingLevel=1)] + public StmtBlockType[][] BatchSequence { + get { + return this.batchSequenceField; + } + set { + this.batchSequenceField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Version { + get { + return this.versionField; + } + set { + this.versionField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Build { + get { + return this.buildField; + } + set { + this.buildField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ClusteredMode { + get { + return this.clusteredModeField; + } + set { + this.clusteredModeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ClusteredModeSpecified { + get { + return this.clusteredModeFieldSpecified; + } + set { + this.clusteredModeFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StmtBlockType { + + private object[] itemsField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ExternalDistributedComputation", typeof(ExternalDistributedComputationType))] + [System.Xml.Serialization.XmlElementAttribute("StmtCond", typeof(StmtCondType))] + [System.Xml.Serialization.XmlElementAttribute("StmtCursor", typeof(StmtCursorType))] + [System.Xml.Serialization.XmlElementAttribute("StmtReceive", typeof(StmtReceiveType))] + [System.Xml.Serialization.XmlElementAttribute("StmtSimple", typeof(StmtSimpleType))] + [System.Xml.Serialization.XmlElementAttribute("StmtUseDb", typeof(StmtUseDbType))] + public object[] Items { + get { + return this.itemsField; + } + set { + this.itemsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ExternalDistributedComputationType { + + private StmtSimpleType[] itemsField; + + private string edcShowplanXmlField; + + /// + [System.Xml.Serialization.XmlElementAttribute("StmtSimple")] + public StmtSimpleType[] Items { + get { + return this.itemsField; + } + set { + this.itemsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string EdcShowplanXml { + get { + return this.edcShowplanXmlField; + } + set { + this.edcShowplanXmlField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StmtSimpleType : BaseStmtInfoType { + + private ParameterSensitivePredicateType[] dispatcherField; + + private QueryPlanType queryPlanField; + + private FunctionType[] uDFField; + + private FunctionType storedProcField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ParameterSensitivePredicate", IsNullable=false)] + public ParameterSensitivePredicateType[] Dispatcher { + get { + return this.dispatcherField; + } + set { + this.dispatcherField = value; + } + } + + /// + public QueryPlanType QueryPlan { + get { + return this.queryPlanField; + } + set { + this.queryPlanField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("UDF")] + public FunctionType[] UDF { + get { + return this.uDFField; + } + set { + this.uDFField = value; + } + } + + /// + public FunctionType StoredProc { + get { + return this.storedProcField; + } + set { + this.storedProcField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ParameterSensitivePredicateType { + + private StatsInfoType[] statisticsInfoField; + + private ScalarExpressionType predicateField; + + private double lowBoundaryField; + + private double highBoundaryField; + + /// + [System.Xml.Serialization.XmlElementAttribute("StatisticsInfo")] + public StatsInfoType[] StatisticsInfo { + get { + return this.statisticsInfoField; + } + set { + this.statisticsInfoField = value; + } + } + + /// + public ScalarExpressionType Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double LowBoundary { + get { + return this.lowBoundaryField; + } + set { + this.lowBoundaryField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double HighBoundary { + get { + return this.highBoundaryField; + } + set { + this.highBoundaryField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StatsInfoType { + + private string databaseField; + + private string schemaField; + + private string tableField; + + private string statisticsField; + + private ulong modificationCountField; + + private double samplingPercentField; + + private System.DateTime lastUpdateField; + + private bool lastUpdateFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Database { + get { + return this.databaseField; + } + set { + this.databaseField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Schema { + get { + return this.schemaField; + } + set { + this.schemaField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Table { + get { + return this.tableField; + } + set { + this.tableField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Statistics { + get { + return this.statisticsField; + } + set { + this.statisticsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ModificationCount { + get { + return this.modificationCountField; + } + set { + this.modificationCountField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double SamplingPercent { + get { + return this.samplingPercentField; + } + set { + this.samplingPercentField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public System.DateTime LastUpdate { + get { + return this.lastUpdateField; + } + set { + this.lastUpdateField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool LastUpdateSpecified { + get { + return this.lastUpdateFieldSpecified; + } + set { + this.lastUpdateFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class CursorPlanType { + + private CursorPlanTypeOperation[] operationField; + + private string cursorNameField; + + private CursorType cursorActualTypeField; + + private bool cursorActualTypeFieldSpecified; + + private CursorType cursorRequestedTypeField; + + private bool cursorRequestedTypeFieldSpecified; + + private CursorPlanTypeCursorConcurrency cursorConcurrencyField; + + private bool cursorConcurrencyFieldSpecified; + + private bool forwardOnlyField; + + private bool forwardOnlyFieldSpecified; + + /// + [System.Xml.Serialization.XmlElementAttribute("Operation")] + public CursorPlanTypeOperation[] Operation { + get { + return this.operationField; + } + set { + this.operationField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string CursorName { + get { + return this.cursorNameField; + } + set { + this.cursorNameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public CursorType CursorActualType { + get { + return this.cursorActualTypeField; + } + set { + this.cursorActualTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool CursorActualTypeSpecified { + get { + return this.cursorActualTypeFieldSpecified; + } + set { + this.cursorActualTypeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public CursorType CursorRequestedType { + get { + return this.cursorRequestedTypeField; + } + set { + this.cursorRequestedTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool CursorRequestedTypeSpecified { + get { + return this.cursorRequestedTypeFieldSpecified; + } + set { + this.cursorRequestedTypeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public CursorPlanTypeCursorConcurrency CursorConcurrency { + get { + return this.cursorConcurrencyField; + } + set { + this.cursorConcurrencyField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool CursorConcurrencySpecified { + get { + return this.cursorConcurrencyFieldSpecified; + } + set { + this.cursorConcurrencyFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ForwardOnly { + get { + return this.forwardOnlyField; + } + set { + this.forwardOnlyField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ForwardOnlySpecified { + get { + return this.forwardOnlyFieldSpecified; + } + set { + this.forwardOnlyFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class CursorPlanTypeOperation { + + private ParameterSensitivePredicateType[] dispatcherField; + + private QueryPlanType queryPlanField; + + private FunctionType[] uDFField; + + private CursorPlanTypeOperationOperationType operationTypeField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ParameterSensitivePredicate", IsNullable=false)] + public ParameterSensitivePredicateType[] Dispatcher { + get { + return this.dispatcherField; + } + set { + this.dispatcherField = value; + } + } + + /// + public QueryPlanType QueryPlan { + get { + return this.queryPlanField; + } + set { + this.queryPlanField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("UDF")] + public FunctionType[] UDF { + get { + return this.uDFField; + } + set { + this.uDFField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public CursorPlanTypeOperationOperationType OperationType { + get { + return this.operationTypeField; + } + set { + this.operationTypeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class QueryPlanType { + + private InternalInfoType internalInfoField; + + private ThreadStatType threadStatField; + + private MissingIndexGroupType[] missingIndexesField; + + private GuessedSelectivityType guessedSelectivityField; + + private UnmatchedIndexesType unmatchedIndexesField; + + private WarningsType warningsField; + + private MemoryGrantType memoryGrantInfoField; + + private OptimizerHardwareDependentPropertiesType optimizerHardwareDependentPropertiesField; + + private StatsInfoType[] optimizerStatsUsageField; + + private TraceFlagListType[] traceFlagsField; + + private WaitStatType[] waitStatsField; + + private QueryExecTimeType queryTimeStatsField; + + private RelOpType relOpField; + + private ColumnReferenceType[] parameterListField; + + private int degreeOfParallelismField; + + private bool degreeOfParallelismFieldSpecified; + + private int effectiveDegreeOfParallelismField; + + private bool effectiveDegreeOfParallelismFieldSpecified; + + private string nonParallelPlanReasonField; + + private ulong memoryGrantField; + + private bool memoryGrantFieldSpecified; + + private ulong cachedPlanSizeField; + + private bool cachedPlanSizeFieldSpecified; + + private ulong compileTimeField; + + private bool compileTimeFieldSpecified; + + private ulong compileCPUField; + + private bool compileCPUFieldSpecified; + + private ulong compileMemoryField; + + private bool compileMemoryFieldSpecified; + + private bool usePlanField; + + private bool usePlanFieldSpecified; + + private bool containsInterleavedExecutionCandidatesField; + + private bool containsInterleavedExecutionCandidatesFieldSpecified; + + private bool containsInlineScalarTsqlUdfsField; + + private bool containsInlineScalarTsqlUdfsFieldSpecified; + + private int queryVariantIDField; + + private bool queryVariantIDFieldSpecified; + + private string dispatcherPlanHandleField; + + /// + public InternalInfoType InternalInfo { + get { + return this.internalInfoField; + } + set { + this.internalInfoField = value; + } + } + + /// + public ThreadStatType ThreadStat { + get { + return this.threadStatField; + } + set { + this.threadStatField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("MissingIndexGroup", IsNullable=false)] + public MissingIndexGroupType[] MissingIndexes { + get { + return this.missingIndexesField; + } + set { + this.missingIndexesField = value; + } + } + + /// + public GuessedSelectivityType GuessedSelectivity { + get { + return this.guessedSelectivityField; + } + set { + this.guessedSelectivityField = value; + } + } + + /// + public UnmatchedIndexesType UnmatchedIndexes { + get { + return this.unmatchedIndexesField; + } + set { + this.unmatchedIndexesField = value; + } + } + + /// + public WarningsType Warnings { + get { + return this.warningsField; + } + set { + this.warningsField = value; + } + } + + /// + public MemoryGrantType MemoryGrantInfo { + get { + return this.memoryGrantInfoField; + } + set { + this.memoryGrantInfoField = value; + } + } + + /// + public OptimizerHardwareDependentPropertiesType OptimizerHardwareDependentProperties { + get { + return this.optimizerHardwareDependentPropertiesField; + } + set { + this.optimizerHardwareDependentPropertiesField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("StatisticsInfo", IsNullable=false)] + public StatsInfoType[] OptimizerStatsUsage { + get { + return this.optimizerStatsUsageField; + } + set { + this.optimizerStatsUsageField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("TraceFlags")] + public TraceFlagListType[] TraceFlags { + get { + return this.traceFlagsField; + } + set { + this.traceFlagsField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Wait", IsNullable=false)] + public WaitStatType[] WaitStats { + get { + return this.waitStatsField; + } + set { + this.waitStatsField = value; + } + } + + /// + public QueryExecTimeType QueryTimeStats { + get { + return this.queryTimeStatsField; + } + set { + this.queryTimeStatsField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] ParameterList { + get { + return this.parameterListField; + } + set { + this.parameterListField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int DegreeOfParallelism { + get { + return this.degreeOfParallelismField; + } + set { + this.degreeOfParallelismField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool DegreeOfParallelismSpecified { + get { + return this.degreeOfParallelismFieldSpecified; + } + set { + this.degreeOfParallelismFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int EffectiveDegreeOfParallelism { + get { + return this.effectiveDegreeOfParallelismField; + } + set { + this.effectiveDegreeOfParallelismField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool EffectiveDegreeOfParallelismSpecified { + get { + return this.effectiveDegreeOfParallelismFieldSpecified; + } + set { + this.effectiveDegreeOfParallelismFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string NonParallelPlanReason { + get { + return this.nonParallelPlanReasonField; + } + set { + this.nonParallelPlanReasonField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong MemoryGrant { + get { + return this.memoryGrantField; + } + set { + this.memoryGrantField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool MemoryGrantSpecified { + get { + return this.memoryGrantFieldSpecified; + } + set { + this.memoryGrantFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong CachedPlanSize { + get { + return this.cachedPlanSizeField; + } + set { + this.cachedPlanSizeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool CachedPlanSizeSpecified { + get { + return this.cachedPlanSizeFieldSpecified; + } + set { + this.cachedPlanSizeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong CompileTime { + get { + return this.compileTimeField; + } + set { + this.compileTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool CompileTimeSpecified { + get { + return this.compileTimeFieldSpecified; + } + set { + this.compileTimeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong CompileCPU { + get { + return this.compileCPUField; + } + set { + this.compileCPUField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool CompileCPUSpecified { + get { + return this.compileCPUFieldSpecified; + } + set { + this.compileCPUFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong CompileMemory { + get { + return this.compileMemoryField; + } + set { + this.compileMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool CompileMemorySpecified { + get { + return this.compileMemoryFieldSpecified; + } + set { + this.compileMemoryFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool UsePlan { + get { + return this.usePlanField; + } + set { + this.usePlanField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool UsePlanSpecified { + get { + return this.usePlanFieldSpecified; + } + set { + this.usePlanFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ContainsInterleavedExecutionCandidates { + get { + return this.containsInterleavedExecutionCandidatesField; + } + set { + this.containsInterleavedExecutionCandidatesField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ContainsInterleavedExecutionCandidatesSpecified { + get { + return this.containsInterleavedExecutionCandidatesFieldSpecified; + } + set { + this.containsInterleavedExecutionCandidatesFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ContainsInlineScalarTsqlUdfs { + get { + return this.containsInlineScalarTsqlUdfsField; + } + set { + this.containsInlineScalarTsqlUdfsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ContainsInlineScalarTsqlUdfsSpecified { + get { + return this.containsInlineScalarTsqlUdfsFieldSpecified; + } + set { + this.containsInlineScalarTsqlUdfsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int QueryVariantID { + get { + return this.queryVariantIDField; + } + set { + this.queryVariantIDField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool QueryVariantIDSpecified { + get { + return this.queryVariantIDFieldSpecified; + } + set { + this.queryVariantIDFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string DispatcherPlanHandle { + get { + return this.dispatcherPlanHandleField; + } + set { + this.dispatcherPlanHandleField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class InternalInfoType { + + private System.Xml.XmlElement[] anyField; + + private System.Xml.XmlAttribute[] anyAttrField; + + /// + [System.Xml.Serialization.XmlAnyElementAttribute()] + public System.Xml.XmlElement[] Any { + get { + return this.anyField; + } + set { + this.anyField = value; + } + } + + /// + [System.Xml.Serialization.XmlAnyAttributeAttribute()] + public System.Xml.XmlAttribute[] AnyAttr { + get { + return this.anyAttrField; + } + set { + this.anyAttrField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ThreadStatType { + + private ThreadReservationType[] threadReservationField; + + private int branchesField; + + private int usedThreadsField; + + private bool usedThreadsFieldSpecified; + + /// + [System.Xml.Serialization.XmlElementAttribute("ThreadReservation")] + public ThreadReservationType[] ThreadReservation { + get { + return this.threadReservationField; + } + set { + this.threadReservationField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int Branches { + get { + return this.branchesField; + } + set { + this.branchesField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int UsedThreads { + get { + return this.usedThreadsField; + } + set { + this.usedThreadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool UsedThreadsSpecified { + get { + return this.usedThreadsFieldSpecified; + } + set { + this.usedThreadsFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ThreadReservationType { + + private int nodeIdField; + + private bool nodeIdFieldSpecified; + + private int reservedThreadsField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int NodeId { + get { + return this.nodeIdField; + } + set { + this.nodeIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool NodeIdSpecified { + get { + return this.nodeIdFieldSpecified; + } + set { + this.nodeIdFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int ReservedThreads { + get { + return this.reservedThreadsField; + } + set { + this.reservedThreadsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class MissingIndexGroupType { + + private MissingIndexType[] missingIndexField; + + private double impactField; + + /// + [System.Xml.Serialization.XmlElementAttribute("MissingIndex")] + public MissingIndexType[] MissingIndex { + get { + return this.missingIndexField; + } + set { + this.missingIndexField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double Impact { + get { + return this.impactField; + } + set { + this.impactField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class MissingIndexType { + + private ColumnGroupType[] columnGroupField; + + private string databaseField; + + private string schemaField; + + private string tableField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ColumnGroup")] + public ColumnGroupType[] ColumnGroup { + get { + return this.columnGroupField; + } + set { + this.columnGroupField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Database { + get { + return this.databaseField; + } + set { + this.databaseField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Schema { + get { + return this.schemaField; + } + set { + this.schemaField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Table { + get { + return this.tableField; + } + set { + this.tableField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ColumnGroupType { + + private ColumnType[] columnField; + + private ColumnGroupTypeUsage usageField; + + /// + [System.Xml.Serialization.XmlElementAttribute("Column")] + public ColumnType[] Column { + get { + return this.columnField; + } + set { + this.columnField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ColumnGroupTypeUsage Usage { + get { + return this.usageField; + } + set { + this.usageField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ColumnType { + + private string nameField; + + private int columnIdField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Name { + get { + return this.nameField; + } + set { + this.nameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int ColumnId { + get { + return this.columnIdField; + } + set { + this.columnIdField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum ColumnGroupTypeUsage { + + /// + EQUALITY, + + /// + INEQUALITY, + + /// + INCLUDE, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class GuessedSelectivityType { + + private ObjectType spatialField; + + /// + public ObjectType Spatial { + get { + return this.spatialField; + } + set { + this.spatialField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ObjectType { + + private string serverField; + + private string databaseField; + + private string schemaField; + + private string tableField; + + private string indexField; + + private bool filteredField; + + private bool filteredFieldSpecified; + + private int onlineInbuildIndexField; + + private bool onlineInbuildIndexFieldSpecified; + + private int onlineIndexBuildMappingIndexField; + + private bool onlineIndexBuildMappingIndexFieldSpecified; + + private string aliasField; + + private int tableReferenceIdField; + + private bool tableReferenceIdFieldSpecified; + + private IndexKindType indexKindField; + + private bool indexKindFieldSpecified; + + private CloneAccessScopeType cloneAccessScopeField; + + private bool cloneAccessScopeFieldSpecified; + + private StorageType storageField; + + private bool storageFieldSpecified; + + private int graphWorkTableTypeField; + + private bool graphWorkTableTypeFieldSpecified; + + private int graphWorkTableIdentifierField; + + private bool graphWorkTableIdentifierFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Server { + get { + return this.serverField; + } + set { + this.serverField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Database { + get { + return this.databaseField; + } + set { + this.databaseField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Schema { + get { + return this.schemaField; + } + set { + this.schemaField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Table { + get { + return this.tableField; + } + set { + this.tableField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Index { + get { + return this.indexField; + } + set { + this.indexField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Filtered { + get { + return this.filteredField; + } + set { + this.filteredField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool FilteredSpecified { + get { + return this.filteredFieldSpecified; + } + set { + this.filteredFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int OnlineInbuildIndex { + get { + return this.onlineInbuildIndexField; + } + set { + this.onlineInbuildIndexField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool OnlineInbuildIndexSpecified { + get { + return this.onlineInbuildIndexFieldSpecified; + } + set { + this.onlineInbuildIndexFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int OnlineIndexBuildMappingIndex { + get { + return this.onlineIndexBuildMappingIndexField; + } + set { + this.onlineIndexBuildMappingIndexField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool OnlineIndexBuildMappingIndexSpecified { + get { + return this.onlineIndexBuildMappingIndexFieldSpecified; + } + set { + this.onlineIndexBuildMappingIndexFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Alias { + get { + return this.aliasField; + } + set { + this.aliasField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int TableReferenceId { + get { + return this.tableReferenceIdField; + } + set { + this.tableReferenceIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool TableReferenceIdSpecified { + get { + return this.tableReferenceIdFieldSpecified; + } + set { + this.tableReferenceIdFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public IndexKindType IndexKind { + get { + return this.indexKindField; + } + set { + this.indexKindField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IndexKindSpecified { + get { + return this.indexKindFieldSpecified; + } + set { + this.indexKindFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public CloneAccessScopeType CloneAccessScope { + get { + return this.cloneAccessScopeField; + } + set { + this.cloneAccessScopeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool CloneAccessScopeSpecified { + get { + return this.cloneAccessScopeFieldSpecified; + } + set { + this.cloneAccessScopeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public StorageType Storage { + get { + return this.storageField; + } + set { + this.storageField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StorageSpecified { + get { + return this.storageFieldSpecified; + } + set { + this.storageFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int GraphWorkTableType { + get { + return this.graphWorkTableTypeField; + } + set { + this.graphWorkTableTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool GraphWorkTableTypeSpecified { + get { + return this.graphWorkTableTypeFieldSpecified; + } + set { + this.graphWorkTableTypeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int GraphWorkTableIdentifier { + get { + return this.graphWorkTableIdentifierField; + } + set { + this.graphWorkTableIdentifierField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool GraphWorkTableIdentifierSpecified { + get { + return this.graphWorkTableIdentifierFieldSpecified; + } + set { + this.graphWorkTableIdentifierFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum IndexKindType { + + /// + Heap, + + /// + Clustered, + + /// + FTSChangeTracking, + + /// + FTSMapping, + + /// + NonClustered, + + /// + PrimaryXML, + + /// + SecondaryXML, + + /// + Spatial, + + /// + ViewClustered, + + /// + ViewNonClustered, + + /// + NonClusteredHash, + + /// + SelectiveXML, + + /// + SecondarySelectiveXML, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum CloneAccessScopeType { + + /// + Primary, + + /// + Secondary, + + /// + Both, + + /// + Either, + + /// + ExactMatch, + + /// + Local, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum StorageType { + + /// + RowStore, + + /// + ColumnStore, + + /// + MemoryOptimized, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class UnmatchedIndexesType { + + private ObjectType[] parameterizationField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Object", IsNullable=false)] + public ObjectType[] Parameterization { + get { + return this.parameterizationField; + } + set { + this.parameterizationField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class WarningsType { + + private object[] itemsField; + + private ItemsChoiceType[] itemsElementNameField; + + private bool noJoinPredicateField; + + private bool noJoinPredicateFieldSpecified; + + private bool spatialGuessField; + + private bool spatialGuessFieldSpecified; + + private bool unmatchedIndexesField; + + private bool unmatchedIndexesFieldSpecified; + + private bool fullUpdateForOnlineIndexBuildField; + + private bool fullUpdateForOnlineIndexBuildFieldSpecified; + + /// + [System.Xml.Serialization.XmlElementAttribute("ColumnsWithNoStatistics", typeof(ColumnReferenceListType))] + [System.Xml.Serialization.XmlElementAttribute("ColumnsWithStaleStatistics", typeof(ColumnReferenceListType))] + [System.Xml.Serialization.XmlElementAttribute("ExchangeSpillDetails", typeof(ExchangeSpillDetailsType))] + [System.Xml.Serialization.XmlElementAttribute("HashSpillDetails", typeof(HashSpillDetailsType))] + [System.Xml.Serialization.XmlElementAttribute("MemoryGrantWarning", typeof(MemoryGrantWarningInfo))] + [System.Xml.Serialization.XmlElementAttribute("PlanAffectingConvert", typeof(AffectingConvertWarningType))] + [System.Xml.Serialization.XmlElementAttribute("SortSpillDetails", typeof(SortSpillDetailsType))] + [System.Xml.Serialization.XmlElementAttribute("SpillOccurred", typeof(SpillOccurredType))] + [System.Xml.Serialization.XmlElementAttribute("SpillToTempDb", typeof(SpillToTempDbType))] + [System.Xml.Serialization.XmlElementAttribute("Wait", typeof(WaitWarningType))] + [System.Xml.Serialization.XmlChoiceIdentifierAttribute("ItemsElementName")] + public object[] Items { + get { + return this.itemsField; + } + set { + this.itemsField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("ItemsElementName")] + [System.Xml.Serialization.XmlIgnoreAttribute()] + public ItemsChoiceType[] ItemsElementName { + get { + return this.itemsElementNameField; + } + set { + this.itemsElementNameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool NoJoinPredicate { + get { + return this.noJoinPredicateField; + } + set { + this.noJoinPredicateField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool NoJoinPredicateSpecified { + get { + return this.noJoinPredicateFieldSpecified; + } + set { + this.noJoinPredicateFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool SpatialGuess { + get { + return this.spatialGuessField; + } + set { + this.spatialGuessField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool SpatialGuessSpecified { + get { + return this.spatialGuessFieldSpecified; + } + set { + this.spatialGuessFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool UnmatchedIndexes { + get { + return this.unmatchedIndexesField; + } + set { + this.unmatchedIndexesField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool UnmatchedIndexesSpecified { + get { + return this.unmatchedIndexesFieldSpecified; + } + set { + this.unmatchedIndexesFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool FullUpdateForOnlineIndexBuild { + get { + return this.fullUpdateForOnlineIndexBuildField; + } + set { + this.fullUpdateForOnlineIndexBuildField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool FullUpdateForOnlineIndexBuildSpecified { + get { + return this.fullUpdateForOnlineIndexBuildFieldSpecified; + } + set { + this.fullUpdateForOnlineIndexBuildFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ColumnReferenceListType { + + private ColumnReferenceType[] columnReferenceField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ColumnReference")] + public ColumnReferenceType[] ColumnReference { + get { + return this.columnReferenceField; + } + set { + this.columnReferenceField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ColumnReferenceType { + + private ScalarType scalarOperatorField; + + private InternalInfoType internalInfoField; + + private string serverField; + + private string databaseField; + + private string schemaField; + + private string tableField; + + private string aliasField; + + private string columnField; + + private bool computedColumnField; + + private bool computedColumnFieldSpecified; + + private string parameterDataTypeField; + + private string parameterCompiledValueField; + + private string parameterRuntimeValueField; + + /// + public ScalarType ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + public InternalInfoType InternalInfo { + get { + return this.internalInfoField; + } + set { + this.internalInfoField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Server { + get { + return this.serverField; + } + set { + this.serverField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Database { + get { + return this.databaseField; + } + set { + this.databaseField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Schema { + get { + return this.schemaField; + } + set { + this.schemaField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Table { + get { + return this.tableField; + } + set { + this.tableField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Alias { + get { + return this.aliasField; + } + set { + this.aliasField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Column { + get { + return this.columnField; + } + set { + this.columnField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ComputedColumn { + get { + return this.computedColumnField; + } + set { + this.computedColumnField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ComputedColumnSpecified { + get { + return this.computedColumnFieldSpecified; + } + set { + this.computedColumnFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string ParameterDataType { + get { + return this.parameterDataTypeField; + } + set { + this.parameterDataTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string ParameterCompiledValue { + get { + return this.parameterCompiledValueField; + } + set { + this.parameterCompiledValueField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string ParameterRuntimeValue { + get { + return this.parameterRuntimeValueField; + } + set { + this.parameterRuntimeValueField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ScalarType { + + private object itemField; + + private InternalInfoType internalInfoField; + + private string scalarStringField; + + /// + [System.Xml.Serialization.XmlElementAttribute("Aggregate", typeof(AggregateType))] + [System.Xml.Serialization.XmlElementAttribute("Arithmetic", typeof(ArithmeticType))] + [System.Xml.Serialization.XmlElementAttribute("Assign", typeof(AssignType))] + [System.Xml.Serialization.XmlElementAttribute("Compare", typeof(CompareType))] + [System.Xml.Serialization.XmlElementAttribute("Const", typeof(ConstType))] + [System.Xml.Serialization.XmlElementAttribute("Convert", typeof(ConvertType))] + [System.Xml.Serialization.XmlElementAttribute("IF", typeof(ConditionalType))] + [System.Xml.Serialization.XmlElementAttribute("Identifier", typeof(IdentType))] + [System.Xml.Serialization.XmlElementAttribute("Intrinsic", typeof(IntrinsicType))] + [System.Xml.Serialization.XmlElementAttribute("Logical", typeof(LogicalType))] + [System.Xml.Serialization.XmlElementAttribute("MultipleAssign", typeof(MultAssignType))] + [System.Xml.Serialization.XmlElementAttribute("ScalarExpressionList", typeof(ScalarExpressionListType))] + [System.Xml.Serialization.XmlElementAttribute("Sequence", typeof(ScalarSequenceType))] + [System.Xml.Serialization.XmlElementAttribute("Subquery", typeof(SubqueryType))] + [System.Xml.Serialization.XmlElementAttribute("UDTMethod", typeof(UDTMethodType))] + [System.Xml.Serialization.XmlElementAttribute("UserDefinedAggregate", typeof(UDAggregateType))] + [System.Xml.Serialization.XmlElementAttribute("UserDefinedFunction", typeof(UDFType))] + public object Item { + get { + return this.itemField; + } + set { + this.itemField = value; + } + } + + /// + public InternalInfoType InternalInfo { + get { + return this.internalInfoField; + } + set { + this.internalInfoField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string ScalarString { + get { + return this.scalarStringField; + } + set { + this.scalarStringField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class AggregateType { + + private ScalarType[] scalarOperatorField; + + private string aggTypeField; + + private bool distinctField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator")] + public ScalarType[] ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string AggType { + get { + return this.aggTypeField; + } + set { + this.aggTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Distinct { + get { + return this.distinctField; + } + set { + this.distinctField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ArithmeticType { + + private ScalarType[] scalarOperatorField; + + private ArithmeticOperationType operationField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator")] + public ScalarType[] ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ArithmeticOperationType Operation { + get { + return this.operationField; + } + set { + this.operationField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum ArithmeticOperationType { + + /// + ADD, + + /// + BIT_ADD, + + /// + BIT_AND, + + /// + BIT_COMBINE, + + /// + BIT_NOT, + + /// + BIT_OR, + + /// + BIT_XOR, + + /// + DIV, + + /// + HASH, + + /// + MINUS, + + /// + MOD, + + /// + MULT, + + /// + SUB, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class AssignType { + + private object itemField; + + private ScalarType scalarOperatorField; + + private ColumnReferenceType[] sourceColumnField; + + private ColumnReferenceType[] targetColumnField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ColumnReference", typeof(ColumnReferenceType), Order=0)] + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator", typeof(ScalarType), Order=0)] + public object Item { + get { + return this.itemField; + } + set { + this.itemField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute(Order=1)] + public ScalarType ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("SourceColumn", Order=2)] + public ColumnReferenceType[] SourceColumn { + get { + return this.sourceColumnField; + } + set { + this.sourceColumnField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("TargetColumn", Order=3)] + public ColumnReferenceType[] TargetColumn { + get { + return this.targetColumnField; + } + set { + this.targetColumnField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class CompareType { + + private ScalarType[] scalarOperatorField; + + private CompareOpType compareOpField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator")] + public ScalarType[] ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public CompareOpType CompareOp { + get { + return this.compareOpField; + } + set { + this.compareOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum CompareOpType { + + /// + [System.Xml.Serialization.XmlEnumAttribute("BINARY IS")] + BINARYIS, + + /// + [System.Xml.Serialization.XmlEnumAttribute("BOTH NULL")] + BOTHNULL, + + /// + EQ, + + /// + GE, + + /// + GT, + + /// + IS, + + /// + [System.Xml.Serialization.XmlEnumAttribute("IS NOT")] + ISNOT, + + /// + [System.Xml.Serialization.XmlEnumAttribute("IS NOT NULL")] + ISNOTNULL, + + /// + [System.Xml.Serialization.XmlEnumAttribute("IS NULL")] + ISNULL, + + /// + LE, + + /// + LT, + + /// + NE, + + /// + [System.Xml.Serialization.XmlEnumAttribute("ONE NULL")] + ONENULL, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ConstType { + + private string constValueField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string ConstValue { + get { + return this.constValueField; + } + set { + this.constValueField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ConvertType { + + private ScalarExpressionType styleField; + + private ScalarType scalarOperatorField; + + private string dataTypeField; + + private int lengthField; + + private bool lengthFieldSpecified; + + private int precisionField; + + private bool precisionFieldSpecified; + + private int scaleField; + + private bool scaleFieldSpecified; + + private int style1Field; + + private bool implicitField; + + /// + public ScalarExpressionType Style { + get { + return this.styleField; + } + set { + this.styleField = value; + } + } + + /// + public ScalarType ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string DataType { + get { + return this.dataTypeField; + } + set { + this.dataTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int Length { + get { + return this.lengthField; + } + set { + this.lengthField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool LengthSpecified { + get { + return this.lengthFieldSpecified; + } + set { + this.lengthFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int Precision { + get { + return this.precisionField; + } + set { + this.precisionField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool PrecisionSpecified { + get { + return this.precisionFieldSpecified; + } + set { + this.precisionFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int Scale { + get { + return this.scaleField; + } + set { + this.scaleField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ScaleSpecified { + get { + return this.scaleFieldSpecified; + } + set { + this.scaleFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute("Style")] + public int Style1 { + get { + return this.style1Field; + } + set { + this.style1Field = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Implicit { + get { + return this.implicitField; + } + set { + this.implicitField = value; + } + } + } + + /// + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SetPredicateElementType))] + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ScalarExpressionType { + + private ScalarType scalarOperatorField; + + /// + public ScalarType ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SetPredicateElementType : ScalarExpressionType { + + private SetPredicateType setPredicateTypeField; + + private bool setPredicateTypeFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public SetPredicateType SetPredicateType { + get { + return this.setPredicateTypeField; + } + set { + this.setPredicateTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool SetPredicateTypeSpecified { + get { + return this.setPredicateTypeFieldSpecified; + } + set { + this.setPredicateTypeFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum SetPredicateType { + + /// + Update, + + /// + Insert, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ConditionalType { + + private ScalarExpressionType conditionField; + + private ScalarExpressionType thenField; + + private ScalarExpressionType elseField; + + /// + public ScalarExpressionType Condition { + get { + return this.conditionField; + } + set { + this.conditionField = value; + } + } + + /// + public ScalarExpressionType Then { + get { + return this.thenField; + } + set { + this.thenField = value; + } + } + + /// + public ScalarExpressionType Else { + get { + return this.elseField; + } + set { + this.elseField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class IdentType { + + private ColumnReferenceType columnReferenceField; + + private string tableField; + + /// + public ColumnReferenceType ColumnReference { + get { + return this.columnReferenceField; + } + set { + this.columnReferenceField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Table { + get { + return this.tableField; + } + set { + this.tableField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class IntrinsicType { + + private ScalarType[] scalarOperatorField; + + private string functionNameField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator")] + public ScalarType[] ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string FunctionName { + get { + return this.functionNameField; + } + set { + this.functionNameField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class LogicalType { + + private ScalarType[] scalarOperatorField; + + private LogicalOperationType operationField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator")] + public ScalarType[] ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public LogicalOperationType Operation { + get { + return this.operationField; + } + set { + this.operationField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum LogicalOperationType { + + /// + AND, + + /// + IMPLIES, + + /// + [System.Xml.Serialization.XmlEnumAttribute("IS NOT NULL")] + ISNOTNULL, + + /// + [System.Xml.Serialization.XmlEnumAttribute("IS NULL")] + ISNULL, + + /// + IS, + + /// + IsFalseOrNull, + + /// + NOT, + + /// + OR, + + /// + XOR, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class MultAssignType { + + private AssignType[] assignField; + + /// + [System.Xml.Serialization.XmlElementAttribute("Assign")] + public AssignType[] Assign { + get { + return this.assignField; + } + set { + this.assignField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ScalarExpressionListType { + + private ScalarType[] scalarOperatorField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator")] + public ScalarType[] ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ScalarSequenceType { + + private string functionNameField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string FunctionName { + get { + return this.functionNameField; + } + set { + this.functionNameField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SubqueryType { + + private ScalarType scalarOperatorField; + + private RelOpType relOpField; + + private SubqueryOperationType operationField; + + /// + public ScalarType ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public SubqueryOperationType Operation { + get { + return this.operationField; + } + set { + this.operationField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RelOpType { + + private ColumnReferenceType[] outputListField; + + private WarningsType warningsField; + + private MemoryFractionsType memoryFractionsField; + + private RunTimeInformationTypeRunTimeCountersPerThread[] runTimeInformationField; + + private RunTimePartitionSummaryType runTimePartitionSummaryField; + + private InternalInfoType internalInfoField; + + private RelOpBaseType itemField; + + private ItemChoiceType itemElementNameField; + + private double avgRowSizeField; + + private double estimateCPUField; + + private double estimateIOField; + + private double estimateRebindsField; + + private double estimateRewindsField; + + private ExecutionModeType estimatedExecutionModeField; + + private bool estimatedExecutionModeFieldSpecified; + + private bool groupExecutedField; + + private bool groupExecutedFieldSpecified; + + private double estimateRowsField; + + private double estimateRowsWithoutRowGoalField; + + private bool estimateRowsWithoutRowGoalFieldSpecified; + + private double estimatedRowsReadField; + + private bool estimatedRowsReadFieldSpecified; + + private LogicalOpType logicalOpField; + + private int nodeIdField; + + private bool nodeIdFieldSpecified; + + private bool parallelField; + + private bool remoteDataAccessField; + + private bool remoteDataAccessFieldSpecified; + + private bool partitionedField; + + private bool partitionedFieldSpecified; + + private PhysicalOpType physicalOpField; + + private bool isAdaptiveField; + + private bool isAdaptiveFieldSpecified; + + private double adaptiveThresholdRowsField; + + private bool adaptiveThresholdRowsFieldSpecified; + + private double estimatedTotalSubtreeCostField; + + private double tableCardinalityField; + + private bool tableCardinalityFieldSpecified; + + private ulong statsCollectionIdField; + + private bool statsCollectionIdFieldSpecified; + + private PhysicalOpType estimatedJoinTypeField; + + private bool estimatedJoinTypeFieldSpecified; + + private double pDWAccumulativeCostField; + + private bool pDWAccumulativeCostFieldSpecified; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] OutputList { + get { + return this.outputListField; + } + set { + this.outputListField = value; + } + } + + /// + public WarningsType Warnings { + get { + return this.warningsField; + } + set { + this.warningsField = value; + } + } + + /// + public MemoryFractionsType MemoryFractions { + get { + return this.memoryFractionsField; + } + set { + this.memoryFractionsField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("RunTimeCountersPerThread", IsNullable=false)] + public RunTimeInformationTypeRunTimeCountersPerThread[] RunTimeInformation { + get { + return this.runTimeInformationField; + } + set { + this.runTimeInformationField = value; + } + } + + /// + public RunTimePartitionSummaryType RunTimePartitionSummary { + get { + return this.runTimePartitionSummaryField; + } + set { + this.runTimePartitionSummaryField = value; + } + } + + /// + public InternalInfoType InternalInfo { + get { + return this.internalInfoField; + } + set { + this.internalInfoField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("AdaptiveJoin", typeof(AdaptiveJoinType))] + [System.Xml.Serialization.XmlElementAttribute("Apply", typeof(JoinType))] + [System.Xml.Serialization.XmlElementAttribute("Assert", typeof(FilterType))] + [System.Xml.Serialization.XmlElementAttribute("BatchHashTableBuild", typeof(BatchHashTableBuildType))] + [System.Xml.Serialization.XmlElementAttribute("Bitmap", typeof(BitmapType))] + [System.Xml.Serialization.XmlElementAttribute("Collapse", typeof(CollapseType))] + [System.Xml.Serialization.XmlElementAttribute("ComputeScalar", typeof(ComputeScalarType))] + [System.Xml.Serialization.XmlElementAttribute("Concat", typeof(ConcatType))] + [System.Xml.Serialization.XmlElementAttribute("ConstTableGet", typeof(GetType))] + [System.Xml.Serialization.XmlElementAttribute("ConstantScan", typeof(ConstantScanType))] + [System.Xml.Serialization.XmlElementAttribute("CreateIndex", typeof(CreateIndexType))] + [System.Xml.Serialization.XmlElementAttribute("Delete", typeof(DMLOpType))] + [System.Xml.Serialization.XmlElementAttribute("DeletedScan", typeof(RowsetType))] + [System.Xml.Serialization.XmlElementAttribute("ExtExtractScan", typeof(RemoteType))] + [System.Xml.Serialization.XmlElementAttribute("Extension", typeof(UDXType))] + [System.Xml.Serialization.XmlElementAttribute("ExternalSelect", typeof(ExternalSelectType))] + [System.Xml.Serialization.XmlElementAttribute("Filter", typeof(FilterType))] + [System.Xml.Serialization.XmlElementAttribute("ForeignKeyReferencesCheck", typeof(ForeignKeyReferencesCheckType))] + [System.Xml.Serialization.XmlElementAttribute("GbAgg", typeof(GbAggType))] + [System.Xml.Serialization.XmlElementAttribute("GbApply", typeof(GbApplyType))] + [System.Xml.Serialization.XmlElementAttribute("Generic", typeof(GenericType))] + [System.Xml.Serialization.XmlElementAttribute("Get", typeof(GetType))] + [System.Xml.Serialization.XmlElementAttribute("Hash", typeof(HashType))] + [System.Xml.Serialization.XmlElementAttribute("IndexScan", typeof(IndexScanType))] + [System.Xml.Serialization.XmlElementAttribute("Insert", typeof(DMLOpType))] + [System.Xml.Serialization.XmlElementAttribute("InsertedScan", typeof(RowsetType))] + [System.Xml.Serialization.XmlElementAttribute("Join", typeof(JoinType))] + [System.Xml.Serialization.XmlElementAttribute("LocalCube", typeof(LocalCubeType))] + [System.Xml.Serialization.XmlElementAttribute("LogRowScan", typeof(RelOpBaseType))] + [System.Xml.Serialization.XmlElementAttribute("Merge", typeof(MergeType))] + [System.Xml.Serialization.XmlElementAttribute("MergeInterval", typeof(SimpleIteratorOneChildType))] + [System.Xml.Serialization.XmlElementAttribute("Move", typeof(MoveType))] + [System.Xml.Serialization.XmlElementAttribute("NestedLoops", typeof(NestedLoopsType))] + [System.Xml.Serialization.XmlElementAttribute("OnlineIndex", typeof(CreateIndexType))] + [System.Xml.Serialization.XmlElementAttribute("Parallelism", typeof(ParallelismType))] + [System.Xml.Serialization.XmlElementAttribute("ParameterTableScan", typeof(RelOpBaseType))] + [System.Xml.Serialization.XmlElementAttribute("PrintDataflow", typeof(RelOpBaseType))] + [System.Xml.Serialization.XmlElementAttribute("Project", typeof(ProjectType))] + [System.Xml.Serialization.XmlElementAttribute("Put", typeof(PutType))] + [System.Xml.Serialization.XmlElementAttribute("RemoteFetch", typeof(RemoteFetchType))] + [System.Xml.Serialization.XmlElementAttribute("RemoteModify", typeof(RemoteModifyType))] + [System.Xml.Serialization.XmlElementAttribute("RemoteQuery", typeof(RemoteQueryType))] + [System.Xml.Serialization.XmlElementAttribute("RemoteRange", typeof(RemoteRangeType))] + [System.Xml.Serialization.XmlElementAttribute("RemoteScan", typeof(RemoteType))] + [System.Xml.Serialization.XmlElementAttribute("RowCountSpool", typeof(SpoolType))] + [System.Xml.Serialization.XmlElementAttribute("ScalarInsert", typeof(ScalarInsertType))] + [System.Xml.Serialization.XmlElementAttribute("Segment", typeof(SegmentType))] + [System.Xml.Serialization.XmlElementAttribute("Sequence", typeof(SequenceType))] + [System.Xml.Serialization.XmlElementAttribute("SequenceProject", typeof(ComputeScalarType))] + [System.Xml.Serialization.XmlElementAttribute("SimpleUpdate", typeof(SimpleUpdateType))] + [System.Xml.Serialization.XmlElementAttribute("Sort", typeof(SortType))] + [System.Xml.Serialization.XmlElementAttribute("Split", typeof(SplitType))] + [System.Xml.Serialization.XmlElementAttribute("Spool", typeof(SpoolType))] + [System.Xml.Serialization.XmlElementAttribute("StreamAggregate", typeof(StreamAggregateType))] + [System.Xml.Serialization.XmlElementAttribute("Switch", typeof(SwitchType))] + [System.Xml.Serialization.XmlElementAttribute("TFP", typeof(PredictFunctionType))] + [System.Xml.Serialization.XmlElementAttribute("TableScan", typeof(TableScanType))] + [System.Xml.Serialization.XmlElementAttribute("TableValuedFunction", typeof(TableValuedFunctionType))] + [System.Xml.Serialization.XmlElementAttribute("Top", typeof(TopType))] + [System.Xml.Serialization.XmlElementAttribute("TopSort", typeof(TopSortType))] + [System.Xml.Serialization.XmlElementAttribute("Union", typeof(ConcatType))] + [System.Xml.Serialization.XmlElementAttribute("UnionAll", typeof(ConcatType))] + [System.Xml.Serialization.XmlElementAttribute("Update", typeof(UpdateType))] + [System.Xml.Serialization.XmlElementAttribute("WindowAggregate", typeof(WindowAggregateType))] + [System.Xml.Serialization.XmlElementAttribute("WindowSpool", typeof(WindowType))] + [System.Xml.Serialization.XmlElementAttribute("XcsScan", typeof(XcsScanType))] + [System.Xml.Serialization.XmlChoiceIdentifierAttribute("ItemElementName")] + public RelOpBaseType Item { + get { + return this.itemField; + } + set { + this.itemField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public ItemChoiceType ItemElementName { + get { + return this.itemElementNameField; + } + set { + this.itemElementNameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double AvgRowSize { + get { + return this.avgRowSizeField; + } + set { + this.avgRowSizeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double EstimateCPU { + get { + return this.estimateCPUField; + } + set { + this.estimateCPUField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double EstimateIO { + get { + return this.estimateIOField; + } + set { + this.estimateIOField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double EstimateRebinds { + get { + return this.estimateRebindsField; + } + set { + this.estimateRebindsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double EstimateRewinds { + get { + return this.estimateRewindsField; + } + set { + this.estimateRewindsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ExecutionModeType EstimatedExecutionMode { + get { + return this.estimatedExecutionModeField; + } + set { + this.estimatedExecutionModeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool EstimatedExecutionModeSpecified { + get { + return this.estimatedExecutionModeFieldSpecified; + } + set { + this.estimatedExecutionModeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool GroupExecuted { + get { + return this.groupExecutedField; + } + set { + this.groupExecutedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool GroupExecutedSpecified { + get { + return this.groupExecutedFieldSpecified; + } + set { + this.groupExecutedFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double EstimateRows { + get { + return this.estimateRowsField; + } + set { + this.estimateRowsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double EstimateRowsWithoutRowGoal { + get { + return this.estimateRowsWithoutRowGoalField; + } + set { + this.estimateRowsWithoutRowGoalField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool EstimateRowsWithoutRowGoalSpecified { + get { + return this.estimateRowsWithoutRowGoalFieldSpecified; + } + set { + this.estimateRowsWithoutRowGoalFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double EstimatedRowsRead { + get { + return this.estimatedRowsReadField; + } + set { + this.estimatedRowsReadField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool EstimatedRowsReadSpecified { + get { + return this.estimatedRowsReadFieldSpecified; + } + set { + this.estimatedRowsReadFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public LogicalOpType LogicalOp { + get { + return this.logicalOpField; + } + set { + this.logicalOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int NodeId { + get { + return this.nodeIdField; + } + set { + this.nodeIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool NodeIdSpecified { + get { + return this.nodeIdFieldSpecified; + } + set { + this.nodeIdFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Parallel { + get { + return this.parallelField; + } + set { + this.parallelField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool RemoteDataAccess { + get { + return this.remoteDataAccessField; + } + set { + this.remoteDataAccessField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool RemoteDataAccessSpecified { + get { + return this.remoteDataAccessFieldSpecified; + } + set { + this.remoteDataAccessFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Partitioned { + get { + return this.partitionedField; + } + set { + this.partitionedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool PartitionedSpecified { + get { + return this.partitionedFieldSpecified; + } + set { + this.partitionedFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public PhysicalOpType PhysicalOp { + get { + return this.physicalOpField; + } + set { + this.physicalOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsAdaptive { + get { + return this.isAdaptiveField; + } + set { + this.isAdaptiveField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsAdaptiveSpecified { + get { + return this.isAdaptiveFieldSpecified; + } + set { + this.isAdaptiveFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double AdaptiveThresholdRows { + get { + return this.adaptiveThresholdRowsField; + } + set { + this.adaptiveThresholdRowsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool AdaptiveThresholdRowsSpecified { + get { + return this.adaptiveThresholdRowsFieldSpecified; + } + set { + this.adaptiveThresholdRowsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double EstimatedTotalSubtreeCost { + get { + return this.estimatedTotalSubtreeCostField; + } + set { + this.estimatedTotalSubtreeCostField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double TableCardinality { + get { + return this.tableCardinalityField; + } + set { + this.tableCardinalityField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool TableCardinalitySpecified { + get { + return this.tableCardinalityFieldSpecified; + } + set { + this.tableCardinalityFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong StatsCollectionId { + get { + return this.statsCollectionIdField; + } + set { + this.statsCollectionIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StatsCollectionIdSpecified { + get { + return this.statsCollectionIdFieldSpecified; + } + set { + this.statsCollectionIdFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public PhysicalOpType EstimatedJoinType { + get { + return this.estimatedJoinTypeField; + } + set { + this.estimatedJoinTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool EstimatedJoinTypeSpecified { + get { + return this.estimatedJoinTypeFieldSpecified; + } + set { + this.estimatedJoinTypeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double PDWAccumulativeCost { + get { + return this.pDWAccumulativeCostField; + } + set { + this.pDWAccumulativeCostField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool PDWAccumulativeCostSpecified { + get { + return this.pDWAccumulativeCostFieldSpecified; + } + set { + this.pDWAccumulativeCostFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class MemoryFractionsType { + + private double inputField; + + private double outputField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double Input { + get { + return this.inputField; + } + set { + this.inputField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double Output { + get { + return this.outputField; + } + set { + this.outputField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RunTimeInformationTypeRunTimeCountersPerThread { + + private int threadField; + + private int brickIdField; + + private bool brickIdFieldSpecified; + + private ulong actualRebindsField; + + private bool actualRebindsFieldSpecified; + + private ulong actualRewindsField; + + private bool actualRewindsFieldSpecified; + + private ulong actualRowsField; + + private ulong actualRowsReadField; + + private bool actualRowsReadFieldSpecified; + + private ulong batchesField; + + private bool batchesFieldSpecified; + + private ulong actualEndOfScansField; + + private ulong actualExecutionsField; + + private ExecutionModeType actualExecutionModeField; + + private bool actualExecutionModeFieldSpecified; + + private ulong taskAddrField; + + private bool taskAddrFieldSpecified; + + private ulong schedulerIdField; + + private bool schedulerIdFieldSpecified; + + private ulong firstActiveTimeField; + + private bool firstActiveTimeFieldSpecified; + + private ulong lastActiveTimeField; + + private bool lastActiveTimeFieldSpecified; + + private ulong openTimeField; + + private bool openTimeFieldSpecified; + + private ulong firstRowTimeField; + + private bool firstRowTimeFieldSpecified; + + private ulong lastRowTimeField; + + private bool lastRowTimeFieldSpecified; + + private ulong closeTimeField; + + private bool closeTimeFieldSpecified; + + private ulong actualElapsedmsField; + + private bool actualElapsedmsFieldSpecified; + + private ulong actualCPUmsField; + + private bool actualCPUmsFieldSpecified; + + private ulong actualScansField; + + private bool actualScansFieldSpecified; + + private ulong actualLogicalReadsField; + + private bool actualLogicalReadsFieldSpecified; + + private ulong actualPhysicalReadsField; + + private bool actualPhysicalReadsFieldSpecified; + + private ulong actualPageServerReadsField; + + private bool actualPageServerReadsFieldSpecified; + + private ulong actualReadAheadsField; + + private bool actualReadAheadsFieldSpecified; + + private ulong actualPageServerReadAheadsField; + + private bool actualPageServerReadAheadsFieldSpecified; + + private ulong actualLobLogicalReadsField; + + private bool actualLobLogicalReadsFieldSpecified; + + private ulong actualLobPhysicalReadsField; + + private bool actualLobPhysicalReadsFieldSpecified; + + private ulong actualLobPageServerReadsField; + + private bool actualLobPageServerReadsFieldSpecified; + + private ulong actualLobReadAheadsField; + + private bool actualLobReadAheadsFieldSpecified; + + private ulong actualLobPageServerReadAheadsField; + + private bool actualLobPageServerReadAheadsFieldSpecified; + + private int segmentReadsField; + + private bool segmentReadsFieldSpecified; + + private int segmentSkipsField; + + private bool segmentSkipsFieldSpecified; + + private ulong actualLocallyAggregatedRowsField; + + private bool actualLocallyAggregatedRowsFieldSpecified; + + private ulong inputMemoryGrantField; + + private bool inputMemoryGrantFieldSpecified; + + private ulong outputMemoryGrantField; + + private bool outputMemoryGrantFieldSpecified; + + private ulong usedMemoryGrantField; + + private bool usedMemoryGrantFieldSpecified; + + private bool isInterleavedExecutedField; + + private bool isInterleavedExecutedFieldSpecified; + + private PhysicalOpType actualJoinTypeField; + + private bool actualJoinTypeFieldSpecified; + + private ulong hpcRowCountField; + + private bool hpcRowCountFieldSpecified; + + private ulong hpcKernelElapsedUsField; + + private bool hpcKernelElapsedUsFieldSpecified; + + private ulong hpcHostToDeviceBytesField; + + private bool hpcHostToDeviceBytesFieldSpecified; + + private ulong hpcDeviceToHostBytesField; + + private bool hpcDeviceToHostBytesFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int Thread { + get { + return this.threadField; + } + set { + this.threadField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int BrickId { + get { + return this.brickIdField; + } + set { + this.brickIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool BrickIdSpecified { + get { + return this.brickIdFieldSpecified; + } + set { + this.brickIdFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualRebinds { + get { + return this.actualRebindsField; + } + set { + this.actualRebindsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualRebindsSpecified { + get { + return this.actualRebindsFieldSpecified; + } + set { + this.actualRebindsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualRewinds { + get { + return this.actualRewindsField; + } + set { + this.actualRewindsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualRewindsSpecified { + get { + return this.actualRewindsFieldSpecified; + } + set { + this.actualRewindsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualRows { + get { + return this.actualRowsField; + } + set { + this.actualRowsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualRowsRead { + get { + return this.actualRowsReadField; + } + set { + this.actualRowsReadField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualRowsReadSpecified { + get { + return this.actualRowsReadFieldSpecified; + } + set { + this.actualRowsReadFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong Batches { + get { + return this.batchesField; + } + set { + this.batchesField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool BatchesSpecified { + get { + return this.batchesFieldSpecified; + } + set { + this.batchesFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualEndOfScans { + get { + return this.actualEndOfScansField; + } + set { + this.actualEndOfScansField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualExecutions { + get { + return this.actualExecutionsField; + } + set { + this.actualExecutionsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ExecutionModeType ActualExecutionMode { + get { + return this.actualExecutionModeField; + } + set { + this.actualExecutionModeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualExecutionModeSpecified { + get { + return this.actualExecutionModeFieldSpecified; + } + set { + this.actualExecutionModeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong TaskAddr { + get { + return this.taskAddrField; + } + set { + this.taskAddrField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool TaskAddrSpecified { + get { + return this.taskAddrFieldSpecified; + } + set { + this.taskAddrFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong SchedulerId { + get { + return this.schedulerIdField; + } + set { + this.schedulerIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool SchedulerIdSpecified { + get { + return this.schedulerIdFieldSpecified; + } + set { + this.schedulerIdFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong FirstActiveTime { + get { + return this.firstActiveTimeField; + } + set { + this.firstActiveTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool FirstActiveTimeSpecified { + get { + return this.firstActiveTimeFieldSpecified; + } + set { + this.firstActiveTimeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong LastActiveTime { + get { + return this.lastActiveTimeField; + } + set { + this.lastActiveTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool LastActiveTimeSpecified { + get { + return this.lastActiveTimeFieldSpecified; + } + set { + this.lastActiveTimeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong OpenTime { + get { + return this.openTimeField; + } + set { + this.openTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool OpenTimeSpecified { + get { + return this.openTimeFieldSpecified; + } + set { + this.openTimeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong FirstRowTime { + get { + return this.firstRowTimeField; + } + set { + this.firstRowTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool FirstRowTimeSpecified { + get { + return this.firstRowTimeFieldSpecified; + } + set { + this.firstRowTimeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong LastRowTime { + get { + return this.lastRowTimeField; + } + set { + this.lastRowTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool LastRowTimeSpecified { + get { + return this.lastRowTimeFieldSpecified; + } + set { + this.lastRowTimeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong CloseTime { + get { + return this.closeTimeField; + } + set { + this.closeTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool CloseTimeSpecified { + get { + return this.closeTimeFieldSpecified; + } + set { + this.closeTimeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualElapsedms { + get { + return this.actualElapsedmsField; + } + set { + this.actualElapsedmsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualElapsedmsSpecified { + get { + return this.actualElapsedmsFieldSpecified; + } + set { + this.actualElapsedmsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualCPUms { + get { + return this.actualCPUmsField; + } + set { + this.actualCPUmsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualCPUmsSpecified { + get { + return this.actualCPUmsFieldSpecified; + } + set { + this.actualCPUmsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualScans { + get { + return this.actualScansField; + } + set { + this.actualScansField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualScansSpecified { + get { + return this.actualScansFieldSpecified; + } + set { + this.actualScansFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualLogicalReads { + get { + return this.actualLogicalReadsField; + } + set { + this.actualLogicalReadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualLogicalReadsSpecified { + get { + return this.actualLogicalReadsFieldSpecified; + } + set { + this.actualLogicalReadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualPhysicalReads { + get { + return this.actualPhysicalReadsField; + } + set { + this.actualPhysicalReadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualPhysicalReadsSpecified { + get { + return this.actualPhysicalReadsFieldSpecified; + } + set { + this.actualPhysicalReadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualPageServerReads { + get { + return this.actualPageServerReadsField; + } + set { + this.actualPageServerReadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualPageServerReadsSpecified { + get { + return this.actualPageServerReadsFieldSpecified; + } + set { + this.actualPageServerReadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualReadAheads { + get { + return this.actualReadAheadsField; + } + set { + this.actualReadAheadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualReadAheadsSpecified { + get { + return this.actualReadAheadsFieldSpecified; + } + set { + this.actualReadAheadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualPageServerReadAheads { + get { + return this.actualPageServerReadAheadsField; + } + set { + this.actualPageServerReadAheadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualPageServerReadAheadsSpecified { + get { + return this.actualPageServerReadAheadsFieldSpecified; + } + set { + this.actualPageServerReadAheadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualLobLogicalReads { + get { + return this.actualLobLogicalReadsField; + } + set { + this.actualLobLogicalReadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualLobLogicalReadsSpecified { + get { + return this.actualLobLogicalReadsFieldSpecified; + } + set { + this.actualLobLogicalReadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualLobPhysicalReads { + get { + return this.actualLobPhysicalReadsField; + } + set { + this.actualLobPhysicalReadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualLobPhysicalReadsSpecified { + get { + return this.actualLobPhysicalReadsFieldSpecified; + } + set { + this.actualLobPhysicalReadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualLobPageServerReads { + get { + return this.actualLobPageServerReadsField; + } + set { + this.actualLobPageServerReadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualLobPageServerReadsSpecified { + get { + return this.actualLobPageServerReadsFieldSpecified; + } + set { + this.actualLobPageServerReadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualLobReadAheads { + get { + return this.actualLobReadAheadsField; + } + set { + this.actualLobReadAheadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualLobReadAheadsSpecified { + get { + return this.actualLobReadAheadsFieldSpecified; + } + set { + this.actualLobReadAheadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualLobPageServerReadAheads { + get { + return this.actualLobPageServerReadAheadsField; + } + set { + this.actualLobPageServerReadAheadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualLobPageServerReadAheadsSpecified { + get { + return this.actualLobPageServerReadAheadsFieldSpecified; + } + set { + this.actualLobPageServerReadAheadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int SegmentReads { + get { + return this.segmentReadsField; + } + set { + this.segmentReadsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool SegmentReadsSpecified { + get { + return this.segmentReadsFieldSpecified; + } + set { + this.segmentReadsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int SegmentSkips { + get { + return this.segmentSkipsField; + } + set { + this.segmentSkipsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool SegmentSkipsSpecified { + get { + return this.segmentSkipsFieldSpecified; + } + set { + this.segmentSkipsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ActualLocallyAggregatedRows { + get { + return this.actualLocallyAggregatedRowsField; + } + set { + this.actualLocallyAggregatedRowsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualLocallyAggregatedRowsSpecified { + get { + return this.actualLocallyAggregatedRowsFieldSpecified; + } + set { + this.actualLocallyAggregatedRowsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong InputMemoryGrant { + get { + return this.inputMemoryGrantField; + } + set { + this.inputMemoryGrantField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool InputMemoryGrantSpecified { + get { + return this.inputMemoryGrantFieldSpecified; + } + set { + this.inputMemoryGrantFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong OutputMemoryGrant { + get { + return this.outputMemoryGrantField; + } + set { + this.outputMemoryGrantField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool OutputMemoryGrantSpecified { + get { + return this.outputMemoryGrantFieldSpecified; + } + set { + this.outputMemoryGrantFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong UsedMemoryGrant { + get { + return this.usedMemoryGrantField; + } + set { + this.usedMemoryGrantField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool UsedMemoryGrantSpecified { + get { + return this.usedMemoryGrantFieldSpecified; + } + set { + this.usedMemoryGrantFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsInterleavedExecuted { + get { + return this.isInterleavedExecutedField; + } + set { + this.isInterleavedExecutedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsInterleavedExecutedSpecified { + get { + return this.isInterleavedExecutedFieldSpecified; + } + set { + this.isInterleavedExecutedFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public PhysicalOpType ActualJoinType { + get { + return this.actualJoinTypeField; + } + set { + this.actualJoinTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ActualJoinTypeSpecified { + get { + return this.actualJoinTypeFieldSpecified; + } + set { + this.actualJoinTypeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong HpcRowCount { + get { + return this.hpcRowCountField; + } + set { + this.hpcRowCountField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool HpcRowCountSpecified { + get { + return this.hpcRowCountFieldSpecified; + } + set { + this.hpcRowCountFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong HpcKernelElapsedUs { + get { + return this.hpcKernelElapsedUsField; + } + set { + this.hpcKernelElapsedUsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool HpcKernelElapsedUsSpecified { + get { + return this.hpcKernelElapsedUsFieldSpecified; + } + set { + this.hpcKernelElapsedUsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong HpcHostToDeviceBytes { + get { + return this.hpcHostToDeviceBytesField; + } + set { + this.hpcHostToDeviceBytesField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool HpcHostToDeviceBytesSpecified { + get { + return this.hpcHostToDeviceBytesFieldSpecified; + } + set { + this.hpcHostToDeviceBytesFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong HpcDeviceToHostBytes { + get { + return this.hpcDeviceToHostBytesField; + } + set { + this.hpcDeviceToHostBytesField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool HpcDeviceToHostBytesSpecified { + get { + return this.hpcDeviceToHostBytesFieldSpecified; + } + set { + this.hpcDeviceToHostBytesFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum ExecutionModeType { + + /// + Row, + + /// + Batch, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum PhysicalOpType { + + /// + [System.Xml.Serialization.XmlEnumAttribute("Adaptive Join")] + AdaptiveJoin, + + /// + Apply, + + /// + Assert, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Batch Hash Table Build")] + BatchHashTableBuild, + + /// + Bitmap, + + /// + Broadcast, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Clustered Index Delete")] + ClusteredIndexDelete, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Clustered Index Insert")] + ClusteredIndexInsert, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Clustered Index Scan")] + ClusteredIndexScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Clustered Index Seek")] + ClusteredIndexSeek, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Clustered Index Update")] + ClusteredIndexUpdate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Clustered Index Merge")] + ClusteredIndexMerge, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Clustered Update")] + ClusteredUpdate, + + /// + Collapse, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Columnstore Index Delete")] + ColumnstoreIndexDelete, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Columnstore Index Insert")] + ColumnstoreIndexInsert, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Columnstore Index Merge")] + ColumnstoreIndexMerge, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Columnstore Index Scan")] + ColumnstoreIndexScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Columnstore Index Update")] + ColumnstoreIndexUpdate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Compute Scalar")] + ComputeScalar, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Compute To Control Node")] + ComputeToControlNode, + + /// + Concatenation, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Constant Scan")] + ConstantScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Constant Table Get")] + ConstantTableGet, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Control To Compute Nodes")] + ControlToComputeNodes, + + /// + Delete, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Deleted Scan")] + DeletedScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("External Broadcast")] + ExternalBroadcast, + + /// + [System.Xml.Serialization.XmlEnumAttribute("External Extraction Scan")] + ExternalExtractionScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("External Local Streaming")] + ExternalLocalStreaming, + + /// + [System.Xml.Serialization.XmlEnumAttribute("External Round Robin")] + ExternalRoundRobin, + + /// + [System.Xml.Serialization.XmlEnumAttribute("External Select")] + ExternalSelect, + + /// + [System.Xml.Serialization.XmlEnumAttribute("External Shuffle")] + ExternalShuffle, + + /// + Filter, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Foreign Key References Check")] + ForeignKeyReferencesCheck, + + /// + GbAgg, + + /// + GbApply, + + /// + Get, + + /// + Generic, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Hash Match")] + HashMatch, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Delete")] + IndexDelete, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Insert")] + IndexInsert, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Scan")] + IndexScan, + + /// + Insert, + + /// + Join, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Seek")] + IndexSeek, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Spool")] + IndexSpool, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Update")] + IndexUpdate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Inserted Scan")] + InsertedScan, + + /// + LocalCube, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Log Row Scan")] + LogRowScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Merge Interval")] + MergeInterval, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Merge Join")] + MergeJoin, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Nested Loops")] + NestedLoops, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Online Index Insert")] + OnlineIndexInsert, + + /// + Parallelism, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Parameter Table Scan")] + ParameterTableScan, + + /// + Print, + + /// + Project, + + /// + Put, + + /// + Rank, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Delete")] + RemoteDelete, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Index Scan")] + RemoteIndexScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Index Seek")] + RemoteIndexSeek, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Insert")] + RemoteInsert, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Query")] + RemoteQuery, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Scan")] + RemoteScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Update")] + RemoteUpdate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("RID Lookup")] + RIDLookup, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Row Count Spool")] + RowCountSpool, + + /// + Segment, + + /// + Sequence, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Sequence Project")] + SequenceProject, + + /// + Shuffle, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Single Source Round Robin Move")] + SingleSourceRoundRobinMove, + + /// + Sort, + + /// + Split, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Stream Aggregate")] + StreamAggregate, + + /// + Switch, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Table Delete")] + TableDelete, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Table Insert")] + TableInsert, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Table Merge")] + TableMerge, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Table Scan")] + TableScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Table Spool")] + TableSpool, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Table Update")] + TableUpdate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Table-valued function")] + Tablevaluedfunction, + + /// + TFP, + + /// + Top, + + /// + Trim, + + /// + UDX, + + /// + Union, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Union All")] + UnionAll, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Window Aggregate")] + WindowAggregate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Window Spool")] + WindowSpool, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Key Lookup")] + KeyLookup, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Extensible Column Store Scan")] + ExtensibleColumnStoreScan, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RunTimePartitionSummaryType { + + private RunTimePartitionSummaryTypePartitionsAccessed partitionsAccessedField; + + /// + public RunTimePartitionSummaryTypePartitionsAccessed PartitionsAccessed { + get { + return this.partitionsAccessedField; + } + set { + this.partitionsAccessedField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RunTimePartitionSummaryTypePartitionsAccessed { + + private RunTimePartitionSummaryTypePartitionsAccessedPartitionRange[] partitionRangeField; + + private ulong partitionCountField; + + /// + [System.Xml.Serialization.XmlElementAttribute("PartitionRange")] + public RunTimePartitionSummaryTypePartitionsAccessedPartitionRange[] PartitionRange { + get { + return this.partitionRangeField; + } + set { + this.partitionRangeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong PartitionCount { + get { + return this.partitionCountField; + } + set { + this.partitionCountField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RunTimePartitionSummaryTypePartitionsAccessedPartitionRange { + + private ulong startField; + + private ulong endField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong Start { + get { + return this.startField; + } + set { + this.startField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong End { + get { + return this.endField; + } + set { + this.endField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class AdaptiveJoinType : RelOpBaseType { + + private ColumnReferenceType[] hashKeysBuildField; + + private ColumnReferenceType[] hashKeysProbeField; + + private ScalarExpressionType buildResidualField; + + private ScalarExpressionType probeResidualField; + + private StarJoinInfoType starJoinInfoField; + + private ScalarExpressionType predicateField; + + private ScalarExpressionType passThruField; + + private ColumnReferenceType[] outerReferencesField; + + private SingleColumnReferenceType partitionIdField; + + private RelOpType[] relOpField; + + private bool bitmapCreatorField; + + private bool bitmapCreatorFieldSpecified; + + private bool optimizedField; + + private bool withOrderedPrefetchField; + + private bool withOrderedPrefetchFieldSpecified; + + private bool withUnorderedPrefetchField; + + private bool withUnorderedPrefetchFieldSpecified; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] HashKeysBuild { + get { + return this.hashKeysBuildField; + } + set { + this.hashKeysBuildField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] HashKeysProbe { + get { + return this.hashKeysProbeField; + } + set { + this.hashKeysProbeField = value; + } + } + + /// + public ScalarExpressionType BuildResidual { + get { + return this.buildResidualField; + } + set { + this.buildResidualField = value; + } + } + + /// + public ScalarExpressionType ProbeResidual { + get { + return this.probeResidualField; + } + set { + this.probeResidualField = value; + } + } + + /// + public StarJoinInfoType StarJoinInfo { + get { + return this.starJoinInfoField; + } + set { + this.starJoinInfoField = value; + } + } + + /// + public ScalarExpressionType Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + public ScalarExpressionType PassThru { + get { + return this.passThruField; + } + set { + this.passThruField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] OuterReferences { + get { + return this.outerReferencesField; + } + set { + this.outerReferencesField = value; + } + } + + /// + public SingleColumnReferenceType PartitionId { + get { + return this.partitionIdField; + } + set { + this.partitionIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool BitmapCreator { + get { + return this.bitmapCreatorField; + } + set { + this.bitmapCreatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool BitmapCreatorSpecified { + get { + return this.bitmapCreatorFieldSpecified; + } + set { + this.bitmapCreatorFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Optimized { + get { + return this.optimizedField; + } + set { + this.optimizedField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool WithOrderedPrefetch { + get { + return this.withOrderedPrefetchField; + } + set { + this.withOrderedPrefetchField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WithOrderedPrefetchSpecified { + get { + return this.withOrderedPrefetchFieldSpecified; + } + set { + this.withOrderedPrefetchFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool WithUnorderedPrefetch { + get { + return this.withUnorderedPrefetchField; + } + set { + this.withUnorderedPrefetchField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WithUnorderedPrefetchSpecified { + get { + return this.withUnorderedPrefetchFieldSpecified; + } + set { + this.withUnorderedPrefetchFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StarJoinInfoType { + + private bool rootField; + + private bool rootFieldSpecified; + + private StarJoinInfoTypeOperationType operationTypeField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Root { + get { + return this.rootField; + } + set { + this.rootField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool RootSpecified { + get { + return this.rootFieldSpecified; + } + set { + this.rootFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public StarJoinInfoTypeOperationType OperationType { + get { + return this.operationTypeField; + } + set { + this.operationTypeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum StarJoinInfoTypeOperationType { + + /// + Fetch, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Intersection")] + IndexIntersection, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Filter")] + IndexFilter, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Lookup")] + IndexLookup, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SingleColumnReferenceType { + + private ColumnReferenceType columnReferenceField; + + /// + public ColumnReferenceType ColumnReference { + get { + return this.columnReferenceField; + } + set { + this.columnReferenceField = value; + } + } + } + + /// + [System.Xml.Serialization.XmlIncludeAttribute(typeof(GetType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(DMLOpType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(LocalCubeType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(GbAggType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(GbApplyType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(JoinType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(ProjectType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(ExternalSelectType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(MoveType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(GenericType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(RemoteType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(RemoteQueryType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(PutType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(RemoteModifyType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(RemoteFetchType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(RemoteRangeType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(BatchHashTableBuildType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SpoolType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(WindowAggregateType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(WindowType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(UDXType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(TopType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SplitType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SequenceType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SegmentType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(NestedLoopsType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(MergeType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(ConcatType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SwitchType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(CollapseType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(BitmapType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SortType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(TopSortType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(StreamAggregateType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(ParallelismType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(ComputeScalarType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(HashType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(TableValuedFunctionType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(PredictFunctionType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(ConstantScanType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(FilterType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SimpleIteratorOneChildType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(RowsetType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(ScalarInsertType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(CreateIndexType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(UpdateType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SimpleUpdateType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(IndexScanType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(XcsScanType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(TableScanType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(ForeignKeyReferencesCheckType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(AdaptiveJoinType))] + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RelOpBaseType { + + private DefinedValuesListTypeDefinedValue[] definedValuesField; + + private InternalInfoType internalInfoField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("DefinedValue", IsNullable=false)] + public DefinedValuesListTypeDefinedValue[] DefinedValues { + get { + return this.definedValuesField; + } + set { + this.definedValuesField = value; + } + } + + /// + public InternalInfoType InternalInfo { + get { + return this.internalInfoField; + } + set { + this.internalInfoField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class DefinedValuesListTypeDefinedValue { + + private object itemField; + + private object[] itemsField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ColumnReference", typeof(ColumnReferenceType), Order=0)] + [System.Xml.Serialization.XmlElementAttribute("ValueVector", typeof(DefinedValuesListTypeDefinedValueValueVector), Order=0)] + public object Item { + get { + return this.itemField; + } + set { + this.itemField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("ColumnReference", typeof(ColumnReferenceType), Order=1)] + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator", typeof(ScalarType), Order=1)] + public object[] Items { + get { + return this.itemsField; + } + set { + this.itemsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class DefinedValuesListTypeDefinedValueValueVector { + + private ColumnReferenceType[] columnReferenceField; + + /// + [System.Xml.Serialization.XmlElementAttribute("ColumnReference")] + public ColumnReferenceType[] ColumnReference { + get { + return this.columnReferenceField; + } + set { + this.columnReferenceField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class GetType : RelOpBaseType { + + private ColumnReferenceType[] bookmarksField; + + private OutputColumnsType outputColumnsField; + + private ScalarType[] generatedDataField; + + private RelOpType[] relOpField; + + private int numRowsField; + + private bool numRowsFieldSpecified; + + private bool isExternalField; + + private bool isExternalFieldSpecified; + + private bool isDistributedField; + + private bool isDistributedFieldSpecified; + + private bool isHashDistributedField; + + private bool isHashDistributedFieldSpecified; + + private bool isReplicatedField; + + private bool isReplicatedFieldSpecified; + + private bool isRoundRobinField; + + private bool isRoundRobinFieldSpecified; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] Bookmarks { + get { + return this.bookmarksField; + } + set { + this.bookmarksField = value; + } + } + + /// + public OutputColumnsType OutputColumns { + get { + return this.outputColumnsField; + } + set { + this.outputColumnsField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ScalarOperator", IsNullable=false)] + public ScalarType[] GeneratedData { + get { + return this.generatedDataField; + } + set { + this.generatedDataField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int NumRows { + get { + return this.numRowsField; + } + set { + this.numRowsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool NumRowsSpecified { + get { + return this.numRowsFieldSpecified; + } + set { + this.numRowsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsExternal { + get { + return this.isExternalField; + } + set { + this.isExternalField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsExternalSpecified { + get { + return this.isExternalFieldSpecified; + } + set { + this.isExternalFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsDistributed { + get { + return this.isDistributedField; + } + set { + this.isDistributedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsDistributedSpecified { + get { + return this.isDistributedFieldSpecified; + } + set { + this.isDistributedFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsHashDistributed { + get { + return this.isHashDistributedField; + } + set { + this.isHashDistributedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsHashDistributedSpecified { + get { + return this.isHashDistributedFieldSpecified; + } + set { + this.isHashDistributedFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsReplicated { + get { + return this.isReplicatedField; + } + set { + this.isReplicatedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsReplicatedSpecified { + get { + return this.isReplicatedFieldSpecified; + } + set { + this.isReplicatedFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsRoundRobin { + get { + return this.isRoundRobinField; + } + set { + this.isRoundRobinField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsRoundRobinSpecified { + get { + return this.isRoundRobinFieldSpecified; + } + set { + this.isRoundRobinFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class OutputColumnsType { + + private DefinedValuesListTypeDefinedValue[] definedValuesField; + + private ObjectType[] objectField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("DefinedValue", IsNullable=false)] + public DefinedValuesListTypeDefinedValue[] DefinedValues { + get { + return this.definedValuesField; + } + set { + this.definedValuesField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("Object")] + public ObjectType[] Object { + get { + return this.objectField; + } + set { + this.objectField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class DMLOpType : RelOpBaseType { + + private AssignType[] assignmentMapField; + + private ObjectType[] sourceTableField; + + private ObjectType[] targetTableField; + + private RelOpType[] relOpField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Assign", IsNullable=false)] + public AssignType[] AssignmentMap { + get { + return this.assignmentMapField; + } + set { + this.assignmentMapField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Object", IsNullable=false)] + public ObjectType[] SourceTable { + get { + return this.sourceTableField; + } + set { + this.sourceTableField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Object", IsNullable=false)] + public ObjectType[] TargetTable { + get { + return this.targetTableField; + } + set { + this.targetTableField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class LocalCubeType : RelOpBaseType { + + private ColumnReferenceType[] groupByField; + + private GroupingSetReferenceType[] groupingSetsField; + + private RelOpType[] relOpField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] GroupBy { + get { + return this.groupByField; + } + set { + this.groupByField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("GroupingSet", IsNullable=false)] + public GroupingSetReferenceType[] GroupingSets { + get { + return this.groupingSetsField; + } + set { + this.groupingSetsField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class GroupingSetReferenceType { + + private string valueField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Value { + get { + return this.valueField; + } + set { + this.valueField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class GbAggType : RelOpBaseType { + + private ColumnReferenceType[] groupByField; + + private DefinedValuesListTypeDefinedValue[] aggFunctionsField; + + private RelOpType[] relOpField; + + private bool isScalarField; + + private bool isScalarFieldSpecified; + + private string aggTypeField; + + private string hintTypeField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] GroupBy { + get { + return this.groupByField; + } + set { + this.groupByField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("DefinedValue", IsNullable=false)] + public DefinedValuesListTypeDefinedValue[] AggFunctions { + get { + return this.aggFunctionsField; + } + set { + this.aggFunctionsField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsScalar { + get { + return this.isScalarField; + } + set { + this.isScalarField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsScalarSpecified { + get { + return this.isScalarFieldSpecified; + } + set { + this.isScalarFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string AggType { + get { + return this.aggTypeField; + } + set { + this.aggTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string HintType { + get { + return this.hintTypeField; + } + set { + this.hintTypeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class GbApplyType : RelOpBaseType { + + private ScalarExpressionType[] predicateField; + + private DefinedValuesListTypeDefinedValue[] aggFunctionsField; + + private RelOpType[] relOpField; + + private string joinTypeField; + + private string aggTypeField; + + /// + [System.Xml.Serialization.XmlElementAttribute("Predicate")] + public ScalarExpressionType[] Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("DefinedValue", IsNullable=false)] + public DefinedValuesListTypeDefinedValue[] AggFunctions { + get { + return this.aggFunctionsField; + } + set { + this.aggFunctionsField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string JoinType { + get { + return this.joinTypeField; + } + set { + this.joinTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string AggType { + get { + return this.aggTypeField; + } + set { + this.aggTypeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class JoinType : RelOpBaseType { + + private ScalarExpressionType[] predicateField; + + private SingleColumnReferenceType[] probeField; + + private RelOpType[] relOpField; + + /// + [System.Xml.Serialization.XmlElementAttribute("Predicate")] + public ScalarExpressionType[] Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("Probe")] + public SingleColumnReferenceType[] Probe { + get { + return this.probeField; + } + set { + this.probeField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ProjectType : RelOpBaseType { + + private RelOpType[] relOpField; + + private bool isNoOpField; + + private bool isNoOpFieldSpecified; + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsNoOp { + get { + return this.isNoOpField; + } + set { + this.isNoOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsNoOpSpecified { + get { + return this.isNoOpFieldSpecified; + } + set { + this.isNoOpFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ExternalSelectType : RelOpBaseType { + + private RelOpType[] relOpField; + + private string materializeOperationField; + + private string distributionTypeField; + + private bool isDistributedField; + + private bool isDistributedFieldSpecified; + + private bool isExternalField; + + private bool isExternalFieldSpecified; + + private bool isFullField; + + private bool isFullFieldSpecified; + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string MaterializeOperation { + get { + return this.materializeOperationField; + } + set { + this.materializeOperationField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string DistributionType { + get { + return this.distributionTypeField; + } + set { + this.distributionTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsDistributed { + get { + return this.isDistributedField; + } + set { + this.isDistributedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsDistributedSpecified { + get { + return this.isDistributedFieldSpecified; + } + set { + this.isDistributedFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsExternal { + get { + return this.isExternalField; + } + set { + this.isExternalField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsExternalSpecified { + get { + return this.isExternalFieldSpecified; + } + set { + this.isExternalFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsFull { + get { + return this.isFullField; + } + set { + this.isFullField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsFullSpecified { + get { + return this.isFullFieldSpecified; + } + set { + this.isFullFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class MoveType : RelOpBaseType { + + private ColumnReferenceType[] distributionKeyField; + + private RelOpType[] relOpField; + + private string moveType1Field; + + private string distributionTypeField; + + private bool isDistributedField; + + private bool isDistributedFieldSpecified; + + private bool isExternalField; + + private bool isExternalFieldSpecified; + + private bool isFullField; + + private bool isFullFieldSpecified; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] DistributionKey { + get { + return this.distributionKeyField; + } + set { + this.distributionKeyField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute("MoveType")] + public string MoveType1 { + get { + return this.moveType1Field; + } + set { + this.moveType1Field = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string DistributionType { + get { + return this.distributionTypeField; + } + set { + this.distributionTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsDistributed { + get { + return this.isDistributedField; + } + set { + this.isDistributedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsDistributedSpecified { + get { + return this.isDistributedFieldSpecified; + } + set { + this.isDistributedFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsExternal { + get { + return this.isExternalField; + } + set { + this.isExternalField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsExternalSpecified { + get { + return this.isExternalFieldSpecified; + } + set { + this.isExternalFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsFull { + get { + return this.isFullField; + } + set { + this.isFullField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsFullSpecified { + get { + return this.isFullFieldSpecified; + } + set { + this.isFullFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class GenericType : RelOpBaseType { + + private RelOpType[] relOpField; + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.Xml.Serialization.XmlIncludeAttribute(typeof(RemoteQueryType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(PutType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(RemoteModifyType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(RemoteFetchType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(RemoteRangeType))] + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RemoteType : RelOpBaseType { + + private string remoteDestinationField; + + private string remoteSourceField; + + private string remoteObjectField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string RemoteDestination { + get { + return this.remoteDestinationField; + } + set { + this.remoteDestinationField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string RemoteSource { + get { + return this.remoteSourceField; + } + set { + this.remoteSourceField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string RemoteObject { + get { + return this.remoteObjectField; + } + set { + this.remoteObjectField = value; + } + } + } + + /// + [System.Xml.Serialization.XmlIncludeAttribute(typeof(PutType))] + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RemoteQueryType : RemoteType { + + private string remoteQueryField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string RemoteQuery { + get { + return this.remoteQueryField; + } + set { + this.remoteQueryField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class PutType : RemoteQueryType { + + private RelOpType relOpField; + + private bool isExternallyComputedField; + + private bool isExternallyComputedFieldSpecified; + + private string shuffleTypeField; + + private string shuffleColumnField; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsExternallyComputed { + get { + return this.isExternallyComputedField; + } + set { + this.isExternallyComputedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsExternallyComputedSpecified { + get { + return this.isExternallyComputedFieldSpecified; + } + set { + this.isExternallyComputedFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string ShuffleType { + get { + return this.shuffleTypeField; + } + set { + this.shuffleTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string ShuffleColumn { + get { + return this.shuffleColumnField; + } + set { + this.shuffleColumnField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RemoteModifyType : RemoteType { + + private ScalarExpressionType setPredicateField; + + private RelOpType relOpField; + + /// + public ScalarExpressionType SetPredicate { + get { + return this.setPredicateField; + } + set { + this.setPredicateField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RemoteFetchType : RemoteType { + + private RelOpType relOpField; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RemoteRangeType : RemoteType { + + private SeekPredicatesType seekPredicatesField; + + /// + public SeekPredicatesType SeekPredicates { + get { + return this.seekPredicatesField; + } + set { + this.seekPredicatesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SeekPredicatesType { + + private object[] itemsField; + + /// + [System.Xml.Serialization.XmlElementAttribute("SeekPredicate", typeof(SeekPredicateType))] + [System.Xml.Serialization.XmlElementAttribute("SeekPredicateNew", typeof(SeekPredicateNewType))] + [System.Xml.Serialization.XmlElementAttribute("SeekPredicatePart", typeof(SeekPredicatePartType))] + public object[] Items { + get { + return this.itemsField; + } + set { + this.itemsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SeekPredicateType { + + private ScanRangeType prefixField; + + private ScanRangeType startRangeField; + + private ScanRangeType endRangeField; + + private SingleColumnReferenceType isNotNullField; + + /// + public ScanRangeType Prefix { + get { + return this.prefixField; + } + set { + this.prefixField = value; + } + } + + /// + public ScanRangeType StartRange { + get { + return this.startRangeField; + } + set { + this.startRangeField = value; + } + } + + /// + public ScanRangeType EndRange { + get { + return this.endRangeField; + } + set { + this.endRangeField = value; + } + } + + /// + public SingleColumnReferenceType IsNotNull { + get { + return this.isNotNullField; + } + set { + this.isNotNullField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ScanRangeType { + + private ColumnReferenceType[] rangeColumnsField; + + private ScalarType[] rangeExpressionsField; + + private CompareOpType scanTypeField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] RangeColumns { + get { + return this.rangeColumnsField; + } + set { + this.rangeColumnsField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ScalarOperator", IsNullable=false)] + public ScalarType[] RangeExpressions { + get { + return this.rangeExpressionsField; + } + set { + this.rangeExpressionsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public CompareOpType ScanType { + get { + return this.scanTypeField; + } + set { + this.scanTypeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SeekPredicateNewType { + + private SeekPredicateType[] seekKeysField; + + /// + [System.Xml.Serialization.XmlElementAttribute("SeekKeys")] + public SeekPredicateType[] SeekKeys { + get { + return this.seekKeysField; + } + set { + this.seekKeysField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SeekPredicatePartType { + + private SeekPredicateNewType[] itemsField; + + /// + [System.Xml.Serialization.XmlElementAttribute("SeekPredicateNew")] + public SeekPredicateNewType[] Items { + get { + return this.itemsField; + } + set { + this.itemsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class BatchHashTableBuildType : RelOpBaseType { + + private RelOpType relOpField; + + private bool bitmapCreatorField; + + private bool bitmapCreatorFieldSpecified; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool BitmapCreator { + get { + return this.bitmapCreatorField; + } + set { + this.bitmapCreatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool BitmapCreatorSpecified { + get { + return this.bitmapCreatorFieldSpecified; + } + set { + this.bitmapCreatorFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SpoolType : RelOpBaseType { + + private object itemField; + + private RelOpType relOpField; + + private bool stackField; + + private bool stackFieldSpecified; + + private int primaryNodeIdField; + + private bool primaryNodeIdFieldSpecified; + + /// + [System.Xml.Serialization.XmlElementAttribute("SeekPredicate", typeof(SeekPredicateType))] + [System.Xml.Serialization.XmlElementAttribute("SeekPredicateNew", typeof(SeekPredicateNewType))] + public object Item { + get { + return this.itemField; + } + set { + this.itemField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Stack { + get { + return this.stackField; + } + set { + this.stackField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StackSpecified { + get { + return this.stackFieldSpecified; + } + set { + this.stackFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int PrimaryNodeId { + get { + return this.primaryNodeIdField; + } + set { + this.primaryNodeIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool PrimaryNodeIdSpecified { + get { + return this.primaryNodeIdFieldSpecified; + } + set { + this.primaryNodeIdFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class WindowAggregateType : RelOpBaseType { + + private RelOpType relOpField; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class WindowType : RelOpBaseType { + + private RelOpType relOpField; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class UDXType : RelOpBaseType { + + private ColumnReferenceType[] usedUDXColumnsField; + + private RelOpType relOpField; + + private string uDXNameField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] UsedUDXColumns { + get { + return this.usedUDXColumnsField; + } + set { + this.usedUDXColumnsField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string UDXName { + get { + return this.uDXNameField; + } + set { + this.uDXNameField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class TopType : RelOpBaseType { + + private ColumnReferenceType[] tieColumnsField; + + private ScalarExpressionType offsetExpressionField; + + private ScalarExpressionType topExpressionField; + + private RelOpType relOpField; + + private bool rowCountField; + + private bool rowCountFieldSpecified; + + private int rowsField; + + private bool rowsFieldSpecified; + + private bool isPercentField; + + private bool isPercentFieldSpecified; + + private bool withTiesField; + + private bool withTiesFieldSpecified; + + private string topLocationField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] TieColumns { + get { + return this.tieColumnsField; + } + set { + this.tieColumnsField = value; + } + } + + /// + public ScalarExpressionType OffsetExpression { + get { + return this.offsetExpressionField; + } + set { + this.offsetExpressionField = value; + } + } + + /// + public ScalarExpressionType TopExpression { + get { + return this.topExpressionField; + } + set { + this.topExpressionField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool RowCount { + get { + return this.rowCountField; + } + set { + this.rowCountField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool RowCountSpecified { + get { + return this.rowCountFieldSpecified; + } + set { + this.rowCountFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int Rows { + get { + return this.rowsField; + } + set { + this.rowsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool RowsSpecified { + get { + return this.rowsFieldSpecified; + } + set { + this.rowsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsPercent { + get { + return this.isPercentField; + } + set { + this.isPercentField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsPercentSpecified { + get { + return this.isPercentFieldSpecified; + } + set { + this.isPercentFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool WithTies { + get { + return this.withTiesField; + } + set { + this.withTiesField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WithTiesSpecified { + get { + return this.withTiesFieldSpecified; + } + set { + this.withTiesFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string TopLocation { + get { + return this.topLocationField; + } + set { + this.topLocationField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SplitType : RelOpBaseType { + + private SingleColumnReferenceType actionColumnField; + + private RelOpType relOpField; + + /// + public SingleColumnReferenceType ActionColumn { + get { + return this.actionColumnField; + } + set { + this.actionColumnField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SequenceType : RelOpBaseType { + + private RelOpType[] relOpField; + + private bool isGraphDBTransitiveClosureField; + + private bool isGraphDBTransitiveClosureFieldSpecified; + + private string graphSequenceIdentifierField; + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsGraphDBTransitiveClosure { + get { + return this.isGraphDBTransitiveClosureField; + } + set { + this.isGraphDBTransitiveClosureField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsGraphDBTransitiveClosureSpecified { + get { + return this.isGraphDBTransitiveClosureFieldSpecified; + } + set { + this.isGraphDBTransitiveClosureFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute(DataType="integer")] + public string GraphSequenceIdentifier { + get { + return this.graphSequenceIdentifierField; + } + set { + this.graphSequenceIdentifierField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SegmentType : RelOpBaseType { + + private ColumnReferenceType[] groupByField; + + private SingleColumnReferenceType segmentColumnField; + + private RelOpType relOpField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] GroupBy { + get { + return this.groupByField; + } + set { + this.groupByField = value; + } + } + + /// + public SingleColumnReferenceType SegmentColumn { + get { + return this.segmentColumnField; + } + set { + this.segmentColumnField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class NestedLoopsType : RelOpBaseType { + + private ScalarExpressionType predicateField; + + private ScalarExpressionType passThruField; + + private ColumnReferenceType[] outerReferencesField; + + private SingleColumnReferenceType partitionIdField; + + private SingleColumnReferenceType probeColumnField; + + private StarJoinInfoType starJoinInfoField; + + private RelOpType[] relOpField; + + private bool optimizedField; + + private bool withOrderedPrefetchField; + + private bool withOrderedPrefetchFieldSpecified; + + private bool withUnorderedPrefetchField; + + private bool withUnorderedPrefetchFieldSpecified; + + /// + public ScalarExpressionType Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + public ScalarExpressionType PassThru { + get { + return this.passThruField; + } + set { + this.passThruField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] OuterReferences { + get { + return this.outerReferencesField; + } + set { + this.outerReferencesField = value; + } + } + + /// + public SingleColumnReferenceType PartitionId { + get { + return this.partitionIdField; + } + set { + this.partitionIdField = value; + } + } + + /// + public SingleColumnReferenceType ProbeColumn { + get { + return this.probeColumnField; + } + set { + this.probeColumnField = value; + } + } + + /// + public StarJoinInfoType StarJoinInfo { + get { + return this.starJoinInfoField; + } + set { + this.starJoinInfoField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Optimized { + get { + return this.optimizedField; + } + set { + this.optimizedField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool WithOrderedPrefetch { + get { + return this.withOrderedPrefetchField; + } + set { + this.withOrderedPrefetchField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WithOrderedPrefetchSpecified { + get { + return this.withOrderedPrefetchFieldSpecified; + } + set { + this.withOrderedPrefetchFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool WithUnorderedPrefetch { + get { + return this.withUnorderedPrefetchField; + } + set { + this.withUnorderedPrefetchField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WithUnorderedPrefetchSpecified { + get { + return this.withUnorderedPrefetchFieldSpecified; + } + set { + this.withUnorderedPrefetchFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class MergeType : RelOpBaseType { + + private ColumnReferenceType[] innerSideJoinColumnsField; + + private ColumnReferenceType[] outerSideJoinColumnsField; + + private ScalarExpressionType residualField; + + private ScalarExpressionType passThruField; + + private StarJoinInfoType starJoinInfoField; + + private RelOpType[] relOpField; + + private bool manyToManyField; + + private bool manyToManyFieldSpecified; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] InnerSideJoinColumns { + get { + return this.innerSideJoinColumnsField; + } + set { + this.innerSideJoinColumnsField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] OuterSideJoinColumns { + get { + return this.outerSideJoinColumnsField; + } + set { + this.outerSideJoinColumnsField = value; + } + } + + /// + public ScalarExpressionType Residual { + get { + return this.residualField; + } + set { + this.residualField = value; + } + } + + /// + public ScalarExpressionType PassThru { + get { + return this.passThruField; + } + set { + this.passThruField = value; + } + } + + /// + public StarJoinInfoType StarJoinInfo { + get { + return this.starJoinInfoField; + } + set { + this.starJoinInfoField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ManyToMany { + get { + return this.manyToManyField; + } + set { + this.manyToManyField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ManyToManySpecified { + get { + return this.manyToManyFieldSpecified; + } + set { + this.manyToManyFieldSpecified = value; + } + } + } + + /// + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SwitchType))] + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ConcatType : RelOpBaseType { + + private RelOpType[] relOpField; + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SwitchType : ConcatType { + + private ScalarExpressionType predicateField; + + /// + public ScalarExpressionType Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class CollapseType : RelOpBaseType { + + private ColumnReferenceType[] groupByField; + + private RelOpType relOpField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] GroupBy { + get { + return this.groupByField; + } + set { + this.groupByField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class BitmapType : RelOpBaseType { + + private ColumnReferenceType[] hashKeysField; + + private RelOpType relOpField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] HashKeys { + get { + return this.hashKeysField; + } + set { + this.hashKeysField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.Xml.Serialization.XmlIncludeAttribute(typeof(TopSortType))] + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SortType : RelOpBaseType { + + private OrderByTypeOrderByColumn[] orderByField; + + private SingleColumnReferenceType partitionIdField; + + private RelOpType relOpField; + + private bool distinctField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("OrderByColumn", IsNullable=false)] + public OrderByTypeOrderByColumn[] OrderBy { + get { + return this.orderByField; + } + set { + this.orderByField = value; + } + } + + /// + public SingleColumnReferenceType PartitionId { + get { + return this.partitionIdField; + } + set { + this.partitionIdField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Distinct { + get { + return this.distinctField; + } + set { + this.distinctField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class OrderByTypeOrderByColumn { + + private ColumnReferenceType columnReferenceField; + + private bool ascendingField; + + /// + public ColumnReferenceType ColumnReference { + get { + return this.columnReferenceField; + } + set { + this.columnReferenceField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Ascending { + get { + return this.ascendingField; + } + set { + this.ascendingField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class TopSortType : SortType { + + private int rowsField; + + private bool withTiesField; + + private bool withTiesFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int Rows { + get { + return this.rowsField; + } + set { + this.rowsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool WithTies { + get { + return this.withTiesField; + } + set { + this.withTiesField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WithTiesSpecified { + get { + return this.withTiesFieldSpecified; + } + set { + this.withTiesFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StreamAggregateType : RelOpBaseType { + + private ColumnReferenceType[] groupByField; + + private RollupInfoType rollupInfoField; + + private RelOpType relOpField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] GroupBy { + get { + return this.groupByField; + } + set { + this.groupByField = value; + } + } + + /// + public RollupInfoType RollupInfo { + get { + return this.rollupInfoField; + } + set { + this.rollupInfoField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RollupInfoType { + + private RollupLevelType[] rollupLevelField; + + private int highestLevelField; + + /// + [System.Xml.Serialization.XmlElementAttribute("RollupLevel")] + public RollupLevelType[] RollupLevel { + get { + return this.rollupLevelField; + } + set { + this.rollupLevelField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int HighestLevel { + get { + return this.highestLevelField; + } + set { + this.highestLevelField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RollupLevelType { + + private int levelField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int Level { + get { + return this.levelField; + } + set { + this.levelField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ParallelismType : RelOpBaseType { + + private ColumnReferenceType[] partitionColumnsField; + + private OrderByTypeOrderByColumn[] orderByField; + + private ColumnReferenceType[] hashKeysField; + + private SingleColumnReferenceType probeColumnField; + + private ScalarExpressionType predicateField; + + private ParallelismTypeActivation activationField; + + private ParallelismTypeBrickRouting brickRoutingField; + + private RelOpType relOpField; + + private PartitionType partitioningTypeField; + + private bool partitioningTypeFieldSpecified; + + private bool remotingField; + + private bool remotingFieldSpecified; + + private bool localParallelismField; + + private bool localParallelismFieldSpecified; + + private bool inRowField; + + private bool inRowFieldSpecified; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] PartitionColumns { + get { + return this.partitionColumnsField; + } + set { + this.partitionColumnsField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("OrderByColumn", IsNullable=false)] + public OrderByTypeOrderByColumn[] OrderBy { + get { + return this.orderByField; + } + set { + this.orderByField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] HashKeys { + get { + return this.hashKeysField; + } + set { + this.hashKeysField = value; + } + } + + /// + public SingleColumnReferenceType ProbeColumn { + get { + return this.probeColumnField; + } + set { + this.probeColumnField = value; + } + } + + /// + public ScalarExpressionType Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + public ParallelismTypeActivation Activation { + get { + return this.activationField; + } + set { + this.activationField = value; + } + } + + /// + public ParallelismTypeBrickRouting BrickRouting { + get { + return this.brickRoutingField; + } + set { + this.brickRoutingField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public PartitionType PartitioningType { + get { + return this.partitioningTypeField; + } + set { + this.partitioningTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool PartitioningTypeSpecified { + get { + return this.partitioningTypeFieldSpecified; + } + set { + this.partitioningTypeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Remoting { + get { + return this.remotingField; + } + set { + this.remotingField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool RemotingSpecified { + get { + return this.remotingFieldSpecified; + } + set { + this.remotingFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool LocalParallelism { + get { + return this.localParallelismField; + } + set { + this.localParallelismField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool LocalParallelismSpecified { + get { + return this.localParallelismFieldSpecified; + } + set { + this.localParallelismFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool InRow { + get { + return this.inRowField; + } + set { + this.inRowField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool InRowSpecified { + get { + return this.inRowFieldSpecified; + } + set { + this.inRowFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ParallelismTypeActivation { + + private ObjectType objectField; + + private ParallelismTypeActivationType typeField; + + private string fragmentEliminationField; + + /// + public ObjectType Object { + get { + return this.objectField; + } + set { + this.objectField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ParallelismTypeActivationType Type { + get { + return this.typeField; + } + set { + this.typeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string FragmentElimination { + get { + return this.fragmentEliminationField; + } + set { + this.fragmentEliminationField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum ParallelismTypeActivationType { + + /// + CloneLocation, + + /// + Resource, + + /// + SingleBrick, + + /// + Region, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ParallelismTypeBrickRouting { + + private ObjectType objectField; + + private SingleColumnReferenceType fragmentIdColumnField; + + /// + public ObjectType Object { + get { + return this.objectField; + } + set { + this.objectField = value; + } + } + + /// + public SingleColumnReferenceType FragmentIdColumn { + get { + return this.fragmentIdColumnField; + } + set { + this.fragmentIdColumnField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum PartitionType { + + /// + Broadcast, + + /// + Demand, + + /// + Hash, + + /// + NoPartitioning, + + /// + Range, + + /// + RoundRobin, + + /// + CloneLocation, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ComputeScalarType : RelOpBaseType { + + private RelOpType relOpField; + + private bool computeSequenceField; + + private bool computeSequenceFieldSpecified; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ComputeSequence { + get { + return this.computeSequenceField; + } + set { + this.computeSequenceField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ComputeSequenceSpecified { + get { + return this.computeSequenceFieldSpecified; + } + set { + this.computeSequenceFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class HashType : RelOpBaseType { + + private ColumnReferenceType[] hashKeysBuildField; + + private ColumnReferenceType[] hashKeysProbeField; + + private ScalarExpressionType buildResidualField; + + private ScalarExpressionType probeResidualField; + + private StarJoinInfoType starJoinInfoField; + + private RelOpType[] relOpField; + + private bool bitmapCreatorField; + + private bool bitmapCreatorFieldSpecified; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] HashKeysBuild { + get { + return this.hashKeysBuildField; + } + set { + this.hashKeysBuildField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ColumnReference", IsNullable=false)] + public ColumnReferenceType[] HashKeysProbe { + get { + return this.hashKeysProbeField; + } + set { + this.hashKeysProbeField = value; + } + } + + /// + public ScalarExpressionType BuildResidual { + get { + return this.buildResidualField; + } + set { + this.buildResidualField = value; + } + } + + /// + public ScalarExpressionType ProbeResidual { + get { + return this.probeResidualField; + } + set { + this.probeResidualField = value; + } + } + + /// + public StarJoinInfoType StarJoinInfo { + get { + return this.starJoinInfoField; + } + set { + this.starJoinInfoField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("RelOp")] + public RelOpType[] RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool BitmapCreator { + get { + return this.bitmapCreatorField; + } + set { + this.bitmapCreatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool BitmapCreatorSpecified { + get { + return this.bitmapCreatorFieldSpecified; + } + set { + this.bitmapCreatorFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class TableValuedFunctionType : RelOpBaseType { + + private ObjectType objectField; + + private ScalarExpressionType predicateField; + + private RelOpType relOpField; + + private ScalarType[] parameterListField; + + /// + public ObjectType Object { + get { + return this.objectField; + } + set { + this.objectField = value; + } + } + + /// + public ScalarExpressionType Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("ScalarOperator", IsNullable=false)] + public ScalarType[] ParameterList { + get { + return this.parameterListField; + } + set { + this.parameterListField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class PredictFunctionType : RelOpBaseType { + + private RelOpType relOpField; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ConstantScanType : RelOpBaseType { + + private ScalarType[][] valuesField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Row", IsNullable=false)] + [System.Xml.Serialization.XmlArrayItemAttribute("ScalarOperator", IsNullable=false, NestingLevel=1)] + public ScalarType[][] Values { + get { + return this.valuesField; + } + set { + this.valuesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class FilterType : RelOpBaseType { + + private RelOpType relOpField; + + private ScalarExpressionType predicateField; + + private bool startupExpressionField; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + public ScalarExpressionType Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool StartupExpression { + get { + return this.startupExpressionField; + } + set { + this.startupExpressionField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SimpleIteratorOneChildType : RelOpBaseType { + + private RelOpType relOpField; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.Xml.Serialization.XmlIncludeAttribute(typeof(ScalarInsertType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(CreateIndexType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(UpdateType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(SimpleUpdateType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(IndexScanType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(XcsScanType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(TableScanType))] + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class RowsetType : RelOpBaseType { + + private ObjectType[] objectField; + + /// + [System.Xml.Serialization.XmlElementAttribute("Object")] + public ObjectType[] Object { + get { + return this.objectField; + } + set { + this.objectField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ScalarInsertType : RowsetType { + + private ScalarExpressionType setPredicateField; + + private bool dMLRequestSortField; + + private bool dMLRequestSortFieldSpecified; + + /// + public ScalarExpressionType SetPredicate { + get { + return this.setPredicateField; + } + set { + this.setPredicateField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool DMLRequestSort { + get { + return this.dMLRequestSortField; + } + set { + this.dMLRequestSortField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool DMLRequestSortSpecified { + get { + return this.dMLRequestSortFieldSpecified; + } + set { + this.dMLRequestSortFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class CreateIndexType : RowsetType { + + private RelOpType relOpField; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class UpdateType : RowsetType { + + private SetPredicateElementType[] setPredicateField; + + private SingleColumnReferenceType probeColumnField; + + private SingleColumnReferenceType actionColumnField; + + private SingleColumnReferenceType originalActionColumnField; + + private AssignType[] assignmentMapField; + + private ObjectType[] sourceTableField; + + private ObjectType[] targetTableField; + + private RelOpType relOpField; + + private bool withOrderedPrefetchField; + + private bool withOrderedPrefetchFieldSpecified; + + private bool withUnorderedPrefetchField; + + private bool withUnorderedPrefetchFieldSpecified; + + private bool dMLRequestSortField; + + private bool dMLRequestSortFieldSpecified; + + /// + [System.Xml.Serialization.XmlElementAttribute("SetPredicate")] + public SetPredicateElementType[] SetPredicate { + get { + return this.setPredicateField; + } + set { + this.setPredicateField = value; + } + } + + /// + public SingleColumnReferenceType ProbeColumn { + get { + return this.probeColumnField; + } + set { + this.probeColumnField = value; + } + } + + /// + public SingleColumnReferenceType ActionColumn { + get { + return this.actionColumnField; + } + set { + this.actionColumnField = value; + } + } + + /// + public SingleColumnReferenceType OriginalActionColumn { + get { + return this.originalActionColumnField; + } + set { + this.originalActionColumnField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Assign", IsNullable=false)] + public AssignType[] AssignmentMap { + get { + return this.assignmentMapField; + } + set { + this.assignmentMapField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Object", IsNullable=false)] + public ObjectType[] SourceTable { + get { + return this.sourceTableField; + } + set { + this.sourceTableField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Object", IsNullable=false)] + public ObjectType[] TargetTable { + get { + return this.targetTableField; + } + set { + this.targetTableField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool WithOrderedPrefetch { + get { + return this.withOrderedPrefetchField; + } + set { + this.withOrderedPrefetchField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WithOrderedPrefetchSpecified { + get { + return this.withOrderedPrefetchFieldSpecified; + } + set { + this.withOrderedPrefetchFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool WithUnorderedPrefetch { + get { + return this.withUnorderedPrefetchField; + } + set { + this.withUnorderedPrefetchField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WithUnorderedPrefetchSpecified { + get { + return this.withUnorderedPrefetchFieldSpecified; + } + set { + this.withUnorderedPrefetchFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool DMLRequestSort { + get { + return this.dMLRequestSortField; + } + set { + this.dMLRequestSortField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool DMLRequestSortSpecified { + get { + return this.dMLRequestSortFieldSpecified; + } + set { + this.dMLRequestSortFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SimpleUpdateType : RowsetType { + + private object itemField; + + private ScalarExpressionType setPredicateField; + + private bool dMLRequestSortField; + + private bool dMLRequestSortFieldSpecified; + + /// + [System.Xml.Serialization.XmlElementAttribute("SeekPredicate", typeof(SeekPredicateType))] + [System.Xml.Serialization.XmlElementAttribute("SeekPredicateNew", typeof(SeekPredicateNewType))] + public object Item { + get { + return this.itemField; + } + set { + this.itemField = value; + } + } + + /// + public ScalarExpressionType SetPredicate { + get { + return this.setPredicateField; + } + set { + this.setPredicateField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool DMLRequestSort { + get { + return this.dMLRequestSortField; + } + set { + this.dMLRequestSortField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool DMLRequestSortSpecified { + get { + return this.dMLRequestSortFieldSpecified; + } + set { + this.dMLRequestSortFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class IndexScanType : RowsetType { + + private SeekPredicatesType seekPredicatesField; + + private ScalarExpressionType[] predicateField; + + private SingleColumnReferenceType partitionIdField; + + private ObjectType[] indexedViewInfoField; + + private bool lookupField; + + private bool lookupFieldSpecified; + + private bool orderedField; + + private OrderType scanDirectionField; + + private bool scanDirectionFieldSpecified; + + private bool forcedIndexField; + + private bool forcedIndexFieldSpecified; + + private bool forceSeekField; + + private bool forceSeekFieldSpecified; + + private int forceSeekColumnCountField; + + private bool forceSeekColumnCountFieldSpecified; + + private bool forceScanField; + + private bool forceScanFieldSpecified; + + private bool noExpandHintField; + + private bool noExpandHintFieldSpecified; + + private StorageType storageField; + + private bool storageFieldSpecified; + + private bool dynamicSeekField; + + private bool dynamicSeekFieldSpecified; + + private string sBSFileUrlField; + + /// + public SeekPredicatesType SeekPredicates { + get { + return this.seekPredicatesField; + } + set { + this.seekPredicatesField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("Predicate")] + public ScalarExpressionType[] Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + public SingleColumnReferenceType PartitionId { + get { + return this.partitionIdField; + } + set { + this.partitionIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Object", IsNullable=false)] + public ObjectType[] IndexedViewInfo { + get { + return this.indexedViewInfoField; + } + set { + this.indexedViewInfoField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Lookup { + get { + return this.lookupField; + } + set { + this.lookupField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool LookupSpecified { + get { + return this.lookupFieldSpecified; + } + set { + this.lookupFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Ordered { + get { + return this.orderedField; + } + set { + this.orderedField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public OrderType ScanDirection { + get { + return this.scanDirectionField; + } + set { + this.scanDirectionField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ScanDirectionSpecified { + get { + return this.scanDirectionFieldSpecified; + } + set { + this.scanDirectionFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ForcedIndex { + get { + return this.forcedIndexField; + } + set { + this.forcedIndexField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ForcedIndexSpecified { + get { + return this.forcedIndexFieldSpecified; + } + set { + this.forcedIndexFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ForceSeek { + get { + return this.forceSeekField; + } + set { + this.forceSeekField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ForceSeekSpecified { + get { + return this.forceSeekFieldSpecified; + } + set { + this.forceSeekFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int ForceSeekColumnCount { + get { + return this.forceSeekColumnCountField; + } + set { + this.forceSeekColumnCountField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ForceSeekColumnCountSpecified { + get { + return this.forceSeekColumnCountFieldSpecified; + } + set { + this.forceSeekColumnCountFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ForceScan { + get { + return this.forceScanField; + } + set { + this.forceScanField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ForceScanSpecified { + get { + return this.forceScanFieldSpecified; + } + set { + this.forceScanFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool NoExpandHint { + get { + return this.noExpandHintField; + } + set { + this.noExpandHintField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool NoExpandHintSpecified { + get { + return this.noExpandHintFieldSpecified; + } + set { + this.noExpandHintFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public StorageType Storage { + get { + return this.storageField; + } + set { + this.storageField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StorageSpecified { + get { + return this.storageFieldSpecified; + } + set { + this.storageFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool DynamicSeek { + get { + return this.dynamicSeekField; + } + set { + this.dynamicSeekField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool DynamicSeekSpecified { + get { + return this.dynamicSeekFieldSpecified; + } + set { + this.dynamicSeekFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string SBSFileUrl { + get { + return this.sBSFileUrlField; + } + set { + this.sBSFileUrlField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum OrderType { + + /// + BACKWARD, + + /// + FORWARD, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class XcsScanType : RowsetType { + + private ScalarExpressionType predicateField; + + private SingleColumnReferenceType partitionIdField; + + private ObjectType[] indexedViewInfoField; + + private RelOpType relOpField; + + private bool orderedField; + + private bool forcedIndexField; + + private bool forcedIndexFieldSpecified; + + private bool forceScanField; + + private bool forceScanFieldSpecified; + + private bool noExpandHintField; + + private bool noExpandHintFieldSpecified; + + private StorageType storageField; + + private bool storageFieldSpecified; + + /// + public ScalarExpressionType Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + public SingleColumnReferenceType PartitionId { + get { + return this.partitionIdField; + } + set { + this.partitionIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Object", IsNullable=false)] + public ObjectType[] IndexedViewInfo { + get { + return this.indexedViewInfoField; + } + set { + this.indexedViewInfoField = value; + } + } + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Ordered { + get { + return this.orderedField; + } + set { + this.orderedField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ForcedIndex { + get { + return this.forcedIndexField; + } + set { + this.forcedIndexField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ForcedIndexSpecified { + get { + return this.forcedIndexFieldSpecified; + } + set { + this.forcedIndexFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ForceScan { + get { + return this.forceScanField; + } + set { + this.forceScanField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ForceScanSpecified { + get { + return this.forceScanFieldSpecified; + } + set { + this.forceScanFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool NoExpandHint { + get { + return this.noExpandHintField; + } + set { + this.noExpandHintField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool NoExpandHintSpecified { + get { + return this.noExpandHintFieldSpecified; + } + set { + this.noExpandHintFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public StorageType Storage { + get { + return this.storageField; + } + set { + this.storageField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StorageSpecified { + get { + return this.storageFieldSpecified; + } + set { + this.storageFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class TableScanType : RowsetType { + + private ScalarExpressionType predicateField; + + private SingleColumnReferenceType partitionIdField; + + private ObjectType[] indexedViewInfoField; + + private bool orderedField; + + private bool forcedIndexField; + + private bool forcedIndexFieldSpecified; + + private bool forceScanField; + + private bool forceScanFieldSpecified; + + private bool noExpandHintField; + + private bool noExpandHintFieldSpecified; + + private StorageType storageField; + + private bool storageFieldSpecified; + + /// + public ScalarExpressionType Predicate { + get { + return this.predicateField; + } + set { + this.predicateField = value; + } + } + + /// + public SingleColumnReferenceType PartitionId { + get { + return this.partitionIdField; + } + set { + this.partitionIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Object", IsNullable=false)] + public ObjectType[] IndexedViewInfo { + get { + return this.indexedViewInfoField; + } + set { + this.indexedViewInfoField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Ordered { + get { + return this.orderedField; + } + set { + this.orderedField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ForcedIndex { + get { + return this.forcedIndexField; + } + set { + this.forcedIndexField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ForcedIndexSpecified { + get { + return this.forcedIndexFieldSpecified; + } + set { + this.forcedIndexFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ForceScan { + get { + return this.forceScanField; + } + set { + this.forceScanField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ForceScanSpecified { + get { + return this.forceScanFieldSpecified; + } + set { + this.forceScanFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool NoExpandHint { + get { + return this.noExpandHintField; + } + set { + this.noExpandHintField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool NoExpandHintSpecified { + get { + return this.noExpandHintFieldSpecified; + } + set { + this.noExpandHintFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public StorageType Storage { + get { + return this.storageField; + } + set { + this.storageField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StorageSpecified { + get { + return this.storageFieldSpecified; + } + set { + this.storageFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ForeignKeyReferencesCheckType : RelOpBaseType { + + private RelOpType relOpField; + + private ForeignKeyReferenceCheckType[] foreignKeyReferenceCheckField; + + private int foreignKeyReferencesCountField; + + private bool foreignKeyReferencesCountFieldSpecified; + + private int noMatchingIndexCountField; + + private bool noMatchingIndexCountFieldSpecified; + + private int partialMatchingIndexCountField; + + private bool partialMatchingIndexCountFieldSpecified; + + /// + public RelOpType RelOp { + get { + return this.relOpField; + } + set { + this.relOpField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("ForeignKeyReferenceCheck")] + public ForeignKeyReferenceCheckType[] ForeignKeyReferenceCheck { + get { + return this.foreignKeyReferenceCheckField; + } + set { + this.foreignKeyReferenceCheckField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int ForeignKeyReferencesCount { + get { + return this.foreignKeyReferencesCountField; + } + set { + this.foreignKeyReferencesCountField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ForeignKeyReferencesCountSpecified { + get { + return this.foreignKeyReferencesCountFieldSpecified; + } + set { + this.foreignKeyReferencesCountFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int NoMatchingIndexCount { + get { + return this.noMatchingIndexCountField; + } + set { + this.noMatchingIndexCountField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool NoMatchingIndexCountSpecified { + get { + return this.noMatchingIndexCountFieldSpecified; + } + set { + this.noMatchingIndexCountFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int PartialMatchingIndexCount { + get { + return this.partialMatchingIndexCountField; + } + set { + this.partialMatchingIndexCountField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool PartialMatchingIndexCountSpecified { + get { + return this.partialMatchingIndexCountFieldSpecified; + } + set { + this.partialMatchingIndexCountFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ForeignKeyReferenceCheckType { + + private IndexScanType indexScanField; + + /// + public IndexScanType IndexScan { + get { + return this.indexScanField; + } + set { + this.indexScanField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan", IncludeInSchema=false)] + public enum ItemChoiceType { + + /// + AdaptiveJoin, + + /// + Apply, + + /// + Assert, + + /// + BatchHashTableBuild, + + /// + Bitmap, + + /// + Collapse, + + /// + ComputeScalar, + + /// + Concat, + + /// + ConstTableGet, + + /// + ConstantScan, + + /// + CreateIndex, + + /// + Delete, + + /// + DeletedScan, + + /// + ExtExtractScan, + + /// + Extension, + + /// + ExternalSelect, + + /// + Filter, + + /// + ForeignKeyReferencesCheck, + + /// + GbAgg, + + /// + GbApply, + + /// + Generic, + + /// + Get, + + /// + Hash, + + /// + IndexScan, + + /// + Insert, + + /// + InsertedScan, + + /// + Join, + + /// + LocalCube, + + /// + LogRowScan, + + /// + Merge, + + /// + MergeInterval, + + /// + Move, + + /// + NestedLoops, + + /// + OnlineIndex, + + /// + Parallelism, + + /// + ParameterTableScan, + + /// + PrintDataflow, + + /// + Project, + + /// + Put, + + /// + RemoteFetch, + + /// + RemoteModify, + + /// + RemoteQuery, + + /// + RemoteRange, + + /// + RemoteScan, + + /// + RowCountSpool, + + /// + ScalarInsert, + + /// + Segment, + + /// + Sequence, + + /// + SequenceProject, + + /// + SimpleUpdate, + + /// + Sort, + + /// + Split, + + /// + Spool, + + /// + StreamAggregate, + + /// + Switch, + + /// + TFP, + + /// + TableScan, + + /// + TableValuedFunction, + + /// + Top, + + /// + TopSort, + + /// + Union, + + /// + UnionAll, + + /// + Update, + + /// + WindowAggregate, + + /// + WindowSpool, + + /// + XcsScan, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum LogicalOpType { + + /// + Aggregate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Anti Diff")] + AntiDiff, + + /// + Assert, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Async Concat")] + AsyncConcat, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Batch Hash Table Build")] + BatchHashTableBuild, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Bitmap Create")] + BitmapCreate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Clustered Index Scan")] + ClusteredIndexScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Clustered Index Seek")] + ClusteredIndexSeek, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Clustered Update")] + ClusteredUpdate, + + /// + Collapse, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Compute Scalar")] + ComputeScalar, + + /// + Concatenation, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Constant Scan")] + ConstantScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Constant Table Get")] + ConstantTableGet, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Cross Join")] + CrossJoin, + + /// + Delete, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Deleted Scan")] + DeletedScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Distinct Sort")] + DistinctSort, + + /// + Distinct, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Distribute Streams")] + DistributeStreams, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Eager Spool")] + EagerSpool, + + /// + [System.Xml.Serialization.XmlEnumAttribute("External Extraction Scan")] + ExternalExtractionScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("External Select")] + ExternalSelect, + + /// + Filter, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Flow Distinct")] + FlowDistinct, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Foreign Key References Check")] + ForeignKeyReferencesCheck, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Full Outer Join")] + FullOuterJoin, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Gather Streams")] + GatherStreams, + + /// + GbAgg, + + /// + GbApply, + + /// + Get, + + /// + Generic, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Inner Apply")] + InnerApply, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Scan")] + IndexScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Index Seek")] + IndexSeek, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Inner Join")] + InnerJoin, + + /// + Insert, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Inserted Scan")] + InsertedScan, + + /// + Intersect, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Intersect All")] + IntersectAll, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Lazy Spool")] + LazySpool, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Left Anti Semi Apply")] + LeftAntiSemiApply, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Left Semi Apply")] + LeftSemiApply, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Left Outer Apply")] + LeftOuterApply, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Left Anti Semi Join")] + LeftAntiSemiJoin, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Left Diff")] + LeftDiff, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Left Diff All")] + LeftDiffAll, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Left Outer Join")] + LeftOuterJoin, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Left Semi Join")] + LeftSemiJoin, + + /// + LocalCube, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Log Row Scan")] + LogRowScan, + + /// + Merge, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Merge Interval")] + MergeInterval, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Merge Stats")] + MergeStats, + + /// + Move, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Parameter Table Scan")] + ParameterTableScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Partial Aggregate")] + PartialAggregate, + + /// + Print, + + /// + Project, + + /// + Put, + + /// + Rank, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Delete")] + RemoteDelete, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Index Scan")] + RemoteIndexScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Index Seek")] + RemoteIndexSeek, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Insert")] + RemoteInsert, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Query")] + RemoteQuery, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Scan")] + RemoteScan, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Remote Update")] + RemoteUpdate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Repartition Streams")] + RepartitionStreams, + + /// + [System.Xml.Serialization.XmlEnumAttribute("RID Lookup")] + RIDLookup, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Right Anti Semi Join")] + RightAntiSemiJoin, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Right Diff")] + RightDiff, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Right Diff All")] + RightDiffAll, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Right Outer Join")] + RightOuterJoin, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Right Semi Join")] + RightSemiJoin, + + /// + Segment, + + /// + Sequence, + + /// + Sort, + + /// + Split, + + /// + Switch, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Table-valued function")] + Tablevaluedfunction, + + /// + TFP, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Table Scan")] + TableScan, + + /// + Top, + + /// + [System.Xml.Serialization.XmlEnumAttribute("TopN Sort")] + TopNSort, + + /// + UDX, + + /// + Union, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Union All")] + UnionAll, + + /// + Update, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Local Stats")] + LocalStats, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Window Spool")] + WindowSpool, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Window Aggregate")] + WindowAggregate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Key Lookup")] + KeyLookup, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Extensible Column Store Scan")] + ExtensibleColumnStoreScan, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum SubqueryOperationType { + + /// + [System.Xml.Serialization.XmlEnumAttribute("EQ ALL")] + EQALL, + + /// + [System.Xml.Serialization.XmlEnumAttribute("EQ ANY")] + EQANY, + + /// + EXISTS, + + /// + [System.Xml.Serialization.XmlEnumAttribute("GE ALL")] + GEALL, + + /// + [System.Xml.Serialization.XmlEnumAttribute("GE ANY")] + GEANY, + + /// + [System.Xml.Serialization.XmlEnumAttribute("GT ALL")] + GTALL, + + /// + [System.Xml.Serialization.XmlEnumAttribute("GT ANY")] + GTANY, + + /// + IN, + + /// + [System.Xml.Serialization.XmlEnumAttribute("LE ALL")] + LEALL, + + /// + [System.Xml.Serialization.XmlEnumAttribute("LE ANY")] + LEANY, + + /// + [System.Xml.Serialization.XmlEnumAttribute("LT ALL")] + LTALL, + + /// + [System.Xml.Serialization.XmlEnumAttribute("LT ANY")] + LTANY, + + /// + [System.Xml.Serialization.XmlEnumAttribute("NE ALL")] + NEALL, + + /// + [System.Xml.Serialization.XmlEnumAttribute("NE ANY")] + NEANY, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class UDTMethodType { + + private CLRFunctionType cLRFunctionField; + + private ScalarType[] scalarOperatorField; + + /// + public CLRFunctionType CLRFunction { + get { + return this.cLRFunctionField; + } + set { + this.cLRFunctionField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator")] + public ScalarType[] ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class CLRFunctionType { + + private string assemblyField; + + private string classField; + + private string methodField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Assembly { + get { + return this.assemblyField; + } + set { + this.assemblyField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Class { + get { + return this.classField; + } + set { + this.classField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Method { + get { + return this.methodField; + } + set { + this.methodField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class UDAggregateType { + + private ObjectType uDAggObjectField; + + private ScalarType[] scalarOperatorField; + + private bool distinctField; + + /// + public ObjectType UDAggObject { + get { + return this.uDAggObjectField; + } + set { + this.uDAggObjectField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator")] + public ScalarType[] ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Distinct { + get { + return this.distinctField; + } + set { + this.distinctField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class UDFType { + + private ScalarType[] scalarOperatorField; + + private CLRFunctionType cLRFunctionField; + + private string functionNameField; + + private bool isClrFunctionField; + + private bool isClrFunctionFieldSpecified; + + /// + [System.Xml.Serialization.XmlElementAttribute("ScalarOperator")] + public ScalarType[] ScalarOperator { + get { + return this.scalarOperatorField; + } + set { + this.scalarOperatorField = value; + } + } + + /// + public CLRFunctionType CLRFunction { + get { + return this.cLRFunctionField; + } + set { + this.cLRFunctionField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string FunctionName { + get { + return this.functionNameField; + } + set { + this.functionNameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsClrFunction { + get { + return this.isClrFunctionField; + } + set { + this.isClrFunctionField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsClrFunctionSpecified { + get { + return this.isClrFunctionFieldSpecified; + } + set { + this.isClrFunctionFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ExchangeSpillDetailsType { + + private ulong writesToTempDbField; + + private bool writesToTempDbFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong WritesToTempDb { + get { + return this.writesToTempDbField; + } + set { + this.writesToTempDbField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WritesToTempDbSpecified { + get { + return this.writesToTempDbFieldSpecified; + } + set { + this.writesToTempDbFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class HashSpillDetailsType { + + private ulong grantedMemoryKbField; + + private bool grantedMemoryKbFieldSpecified; + + private ulong usedMemoryKbField; + + private bool usedMemoryKbFieldSpecified; + + private ulong writesToTempDbField; + + private bool writesToTempDbFieldSpecified; + + private ulong readsFromTempDbField; + + private bool readsFromTempDbFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong GrantedMemoryKb { + get { + return this.grantedMemoryKbField; + } + set { + this.grantedMemoryKbField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool GrantedMemoryKbSpecified { + get { + return this.grantedMemoryKbFieldSpecified; + } + set { + this.grantedMemoryKbFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong UsedMemoryKb { + get { + return this.usedMemoryKbField; + } + set { + this.usedMemoryKbField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool UsedMemoryKbSpecified { + get { + return this.usedMemoryKbFieldSpecified; + } + set { + this.usedMemoryKbFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong WritesToTempDb { + get { + return this.writesToTempDbField; + } + set { + this.writesToTempDbField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WritesToTempDbSpecified { + get { + return this.writesToTempDbFieldSpecified; + } + set { + this.writesToTempDbFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ReadsFromTempDb { + get { + return this.readsFromTempDbField; + } + set { + this.readsFromTempDbField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ReadsFromTempDbSpecified { + get { + return this.readsFromTempDbFieldSpecified; + } + set { + this.readsFromTempDbFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class MemoryGrantWarningInfo { + + private MemoryGrantWarningType grantWarningKindField; + + private ulong requestedMemoryField; + + private ulong grantedMemoryField; + + private ulong maxUsedMemoryField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public MemoryGrantWarningType GrantWarningKind { + get { + return this.grantWarningKindField; + } + set { + this.grantWarningKindField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong RequestedMemory { + get { + return this.requestedMemoryField; + } + set { + this.requestedMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong GrantedMemory { + get { + return this.grantedMemoryField; + } + set { + this.grantedMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong MaxUsedMemory { + get { + return this.maxUsedMemoryField; + } + set { + this.maxUsedMemoryField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum MemoryGrantWarningType { + + /// + [System.Xml.Serialization.XmlEnumAttribute("Excessive Grant")] + ExcessiveGrant, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Used More Than Granted")] + UsedMoreThanGranted, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Grant Increase")] + GrantIncrease, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class AffectingConvertWarningType { + + private AffectingConvertWarningTypeConvertIssue convertIssueField; + + private string expressionField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public AffectingConvertWarningTypeConvertIssue ConvertIssue { + get { + return this.convertIssueField; + } + set { + this.convertIssueField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Expression { + get { + return this.expressionField; + } + set { + this.expressionField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum AffectingConvertWarningTypeConvertIssue { + + /// + [System.Xml.Serialization.XmlEnumAttribute("Cardinality Estimate")] + CardinalityEstimate, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Seek Plan")] + SeekPlan, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SortSpillDetailsType { + + private ulong grantedMemoryKbField; + + private bool grantedMemoryKbFieldSpecified; + + private ulong usedMemoryKbField; + + private bool usedMemoryKbFieldSpecified; + + private ulong writesToTempDbField; + + private bool writesToTempDbFieldSpecified; + + private ulong readsFromTempDbField; + + private bool readsFromTempDbFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong GrantedMemoryKb { + get { + return this.grantedMemoryKbField; + } + set { + this.grantedMemoryKbField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool GrantedMemoryKbSpecified { + get { + return this.grantedMemoryKbFieldSpecified; + } + set { + this.grantedMemoryKbFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong UsedMemoryKb { + get { + return this.usedMemoryKbField; + } + set { + this.usedMemoryKbField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool UsedMemoryKbSpecified { + get { + return this.usedMemoryKbFieldSpecified; + } + set { + this.usedMemoryKbFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong WritesToTempDb { + get { + return this.writesToTempDbField; + } + set { + this.writesToTempDbField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WritesToTempDbSpecified { + get { + return this.writesToTempDbFieldSpecified; + } + set { + this.writesToTempDbFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ReadsFromTempDb { + get { + return this.readsFromTempDbField; + } + set { + this.readsFromTempDbField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ReadsFromTempDbSpecified { + get { + return this.readsFromTempDbFieldSpecified; + } + set { + this.readsFromTempDbFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SpillOccurredType { + + private bool detailField; + + private bool detailFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool Detail { + get { + return this.detailField; + } + set { + this.detailField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool DetailSpecified { + get { + return this.detailFieldSpecified; + } + set { + this.detailFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SpillToTempDbType { + + private ulong spillLevelField; + + private bool spillLevelFieldSpecified; + + private ulong spilledThreadCountField; + + private bool spilledThreadCountFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong SpillLevel { + get { + return this.spillLevelField; + } + set { + this.spillLevelField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool SpillLevelSpecified { + get { + return this.spillLevelFieldSpecified; + } + set { + this.spillLevelFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong SpilledThreadCount { + get { + return this.spilledThreadCountField; + } + set { + this.spilledThreadCountField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool SpilledThreadCountSpecified { + get { + return this.spilledThreadCountFieldSpecified; + } + set { + this.spilledThreadCountFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class WaitWarningType { + + private WaitWarningTypeWaitType waitTypeField; + + private ulong waitTimeField; + + private bool waitTimeFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public WaitWarningTypeWaitType WaitType { + get { + return this.waitTypeField; + } + set { + this.waitTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong WaitTime { + get { + return this.waitTimeField; + } + set { + this.waitTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool WaitTimeSpecified { + get { + return this.waitTimeFieldSpecified; + } + set { + this.waitTimeFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum WaitWarningTypeWaitType { + + /// + [System.Xml.Serialization.XmlEnumAttribute("Memory Grant")] + MemoryGrant, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan", IncludeInSchema=false)] + public enum ItemsChoiceType { + + /// + ColumnsWithNoStatistics, + + /// + ColumnsWithStaleStatistics, + + /// + ExchangeSpillDetails, + + /// + HashSpillDetails, + + /// + MemoryGrantWarning, + + /// + PlanAffectingConvert, + + /// + SortSpillDetails, + + /// + SpillOccurred, + + /// + SpillToTempDb, + + /// + Wait, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class MemoryGrantType { + + private ulong serialRequiredMemoryField; + + private ulong serialDesiredMemoryField; + + private ulong requiredMemoryField; + + private bool requiredMemoryFieldSpecified; + + private ulong desiredMemoryField; + + private bool desiredMemoryFieldSpecified; + + private ulong requestedMemoryField; + + private bool requestedMemoryFieldSpecified; + + private ulong grantWaitTimeField; + + private bool grantWaitTimeFieldSpecified; + + private ulong grantedMemoryField; + + private bool grantedMemoryFieldSpecified; + + private ulong maxUsedMemoryField; + + private bool maxUsedMemoryFieldSpecified; + + private ulong maxQueryMemoryField; + + private bool maxQueryMemoryFieldSpecified; + + private ulong lastRequestedMemoryField; + + private bool lastRequestedMemoryFieldSpecified; + + private MemoryGrantFeedbackInfoType isMemoryGrantFeedbackAdjustedField; + + private bool isMemoryGrantFeedbackAdjustedFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong SerialRequiredMemory { + get { + return this.serialRequiredMemoryField; + } + set { + this.serialRequiredMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong SerialDesiredMemory { + get { + return this.serialDesiredMemoryField; + } + set { + this.serialDesiredMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong RequiredMemory { + get { + return this.requiredMemoryField; + } + set { + this.requiredMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool RequiredMemorySpecified { + get { + return this.requiredMemoryFieldSpecified; + } + set { + this.requiredMemoryFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong DesiredMemory { + get { + return this.desiredMemoryField; + } + set { + this.desiredMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool DesiredMemorySpecified { + get { + return this.desiredMemoryFieldSpecified; + } + set { + this.desiredMemoryFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong RequestedMemory { + get { + return this.requestedMemoryField; + } + set { + this.requestedMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool RequestedMemorySpecified { + get { + return this.requestedMemoryFieldSpecified; + } + set { + this.requestedMemoryFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong GrantWaitTime { + get { + return this.grantWaitTimeField; + } + set { + this.grantWaitTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool GrantWaitTimeSpecified { + get { + return this.grantWaitTimeFieldSpecified; + } + set { + this.grantWaitTimeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong GrantedMemory { + get { + return this.grantedMemoryField; + } + set { + this.grantedMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool GrantedMemorySpecified { + get { + return this.grantedMemoryFieldSpecified; + } + set { + this.grantedMemoryFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong MaxUsedMemory { + get { + return this.maxUsedMemoryField; + } + set { + this.maxUsedMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool MaxUsedMemorySpecified { + get { + return this.maxUsedMemoryFieldSpecified; + } + set { + this.maxUsedMemoryFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong MaxQueryMemory { + get { + return this.maxQueryMemoryField; + } + set { + this.maxQueryMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool MaxQueryMemorySpecified { + get { + return this.maxQueryMemoryFieldSpecified; + } + set { + this.maxQueryMemoryFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong LastRequestedMemory { + get { + return this.lastRequestedMemoryField; + } + set { + this.lastRequestedMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool LastRequestedMemorySpecified { + get { + return this.lastRequestedMemoryFieldSpecified; + } + set { + this.lastRequestedMemoryFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public MemoryGrantFeedbackInfoType IsMemoryGrantFeedbackAdjusted { + get { + return this.isMemoryGrantFeedbackAdjustedField; + } + set { + this.isMemoryGrantFeedbackAdjustedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsMemoryGrantFeedbackAdjustedSpecified { + get { + return this.isMemoryGrantFeedbackAdjustedFieldSpecified; + } + set { + this.isMemoryGrantFeedbackAdjustedFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum MemoryGrantFeedbackInfoType { + + /// + [System.Xml.Serialization.XmlEnumAttribute("Yes: Adjusting")] + YesAdjusting, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Yes: Stable")] + YesStable, + + /// + [System.Xml.Serialization.XmlEnumAttribute("No: First Execution")] + NoFirstExecution, + + /// + [System.Xml.Serialization.XmlEnumAttribute("No: Accurate Grant")] + NoAccurateGrant, + + /// + [System.Xml.Serialization.XmlEnumAttribute("No: Feedback Disabled")] + NoFeedbackDisabled, + + /// + [System.Xml.Serialization.XmlEnumAttribute("Yes: Percentile Adjusting")] + YesPercentileAdjusting, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class OptimizerHardwareDependentPropertiesType { + + private ulong estimatedAvailableMemoryGrantField; + + private ulong estimatedPagesCachedField; + + private ulong estimatedAvailableDegreeOfParallelismField; + + private bool estimatedAvailableDegreeOfParallelismFieldSpecified; + + private ulong maxCompileMemoryField; + + private bool maxCompileMemoryFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong EstimatedAvailableMemoryGrant { + get { + return this.estimatedAvailableMemoryGrantField; + } + set { + this.estimatedAvailableMemoryGrantField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong EstimatedPagesCached { + get { + return this.estimatedPagesCachedField; + } + set { + this.estimatedPagesCachedField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong EstimatedAvailableDegreeOfParallelism { + get { + return this.estimatedAvailableDegreeOfParallelismField; + } + set { + this.estimatedAvailableDegreeOfParallelismField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool EstimatedAvailableDegreeOfParallelismSpecified { + get { + return this.estimatedAvailableDegreeOfParallelismFieldSpecified; + } + set { + this.estimatedAvailableDegreeOfParallelismFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong MaxCompileMemory { + get { + return this.maxCompileMemoryField; + } + set { + this.maxCompileMemoryField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool MaxCompileMemorySpecified { + get { + return this.maxCompileMemoryFieldSpecified; + } + set { + this.maxCompileMemoryFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class TraceFlagListType { + + private TraceFlagType[] traceFlagField; + + private bool isCompileTimeField; + + /// + [System.Xml.Serialization.XmlElementAttribute("TraceFlag")] + public TraceFlagType[] TraceFlag { + get { + return this.traceFlagField; + } + set { + this.traceFlagField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsCompileTime { + get { + return this.isCompileTimeField; + } + set { + this.isCompileTimeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class TraceFlagType { + + private ulong valueField; + + private TraceFlagScopeType scopeField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong Value { + get { + return this.valueField; + } + set { + this.valueField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public TraceFlagScopeType Scope { + get { + return this.scopeField; + } + set { + this.scopeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum TraceFlagScopeType { + + /// + Global, + + /// + Session, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class WaitStatType { + + private string waitTypeField; + + private ulong waitTimeMsField; + + private ulong waitCountField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string WaitType { + get { + return this.waitTypeField; + } + set { + this.waitTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong WaitTimeMs { + get { + return this.waitTimeMsField; + } + set { + this.waitTimeMsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong WaitCount { + get { + return this.waitCountField; + } + set { + this.waitCountField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class QueryExecTimeType { + + private ulong cpuTimeField; + + private ulong elapsedTimeField; + + private ulong udfCpuTimeField; + + private bool udfCpuTimeFieldSpecified; + + private ulong udfElapsedTimeField; + + private bool udfElapsedTimeFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong CpuTime { + get { + return this.cpuTimeField; + } + set { + this.cpuTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ElapsedTime { + get { + return this.elapsedTimeField; + } + set { + this.elapsedTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong UdfCpuTime { + get { + return this.udfCpuTimeField; + } + set { + this.udfCpuTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool UdfCpuTimeSpecified { + get { + return this.udfCpuTimeFieldSpecified; + } + set { + this.udfCpuTimeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong UdfElapsedTime { + get { + return this.udfElapsedTimeField; + } + set { + this.udfElapsedTimeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool UdfElapsedTimeSpecified { + get { + return this.udfElapsedTimeFieldSpecified; + } + set { + this.udfElapsedTimeFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class FunctionType { + + private StmtBlockType statementsField; + + private string procNameField; + + private bool isNativelyCompiledField; + + private bool isNativelyCompiledFieldSpecified; + + /// + public StmtBlockType Statements { + get { + return this.statementsField; + } + set { + this.statementsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string ProcName { + get { + return this.procNameField; + } + set { + this.procNameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool IsNativelyCompiled { + get { + return this.isNativelyCompiledField; + } + set { + this.isNativelyCompiledField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool IsNativelyCompiledSpecified { + get { + return this.isNativelyCompiledFieldSpecified; + } + set { + this.isNativelyCompiledFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum CursorPlanTypeOperationOperationType { + + /// + FetchQuery, + + /// + PopulateQuery, + + /// + RefreshQuery, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum CursorType { + + /// + Dynamic, + + /// + FastForward, + + /// + Keyset, + + /// + SnapShot, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum CursorPlanTypeCursorConcurrency { + + /// + [System.Xml.Serialization.XmlEnumAttribute("Read Only")] + ReadOnly, + + /// + Pessimistic, + + /// + Optimistic, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class SetOptionsType { + + private bool aNSI_NULLSField; + + private bool aNSI_NULLSFieldSpecified; + + private bool aNSI_PADDINGField; + + private bool aNSI_PADDINGFieldSpecified; + + private bool aNSI_WARNINGSField; + + private bool aNSI_WARNINGSFieldSpecified; + + private bool aRITHABORTField; + + private bool aRITHABORTFieldSpecified; + + private bool cONCAT_NULL_YIELDS_NULLField; + + private bool cONCAT_NULL_YIELDS_NULLFieldSpecified; + + private bool nUMERIC_ROUNDABORTField; + + private bool nUMERIC_ROUNDABORTFieldSpecified; + + private bool qUOTED_IDENTIFIERField; + + private bool qUOTED_IDENTIFIERFieldSpecified; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ANSI_NULLS { + get { + return this.aNSI_NULLSField; + } + set { + this.aNSI_NULLSField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ANSI_NULLSSpecified { + get { + return this.aNSI_NULLSFieldSpecified; + } + set { + this.aNSI_NULLSFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ANSI_PADDING { + get { + return this.aNSI_PADDINGField; + } + set { + this.aNSI_PADDINGField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ANSI_PADDINGSpecified { + get { + return this.aNSI_PADDINGFieldSpecified; + } + set { + this.aNSI_PADDINGFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ANSI_WARNINGS { + get { + return this.aNSI_WARNINGSField; + } + set { + this.aNSI_WARNINGSField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ANSI_WARNINGSSpecified { + get { + return this.aNSI_WARNINGSFieldSpecified; + } + set { + this.aNSI_WARNINGSFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool ARITHABORT { + get { + return this.aRITHABORTField; + } + set { + this.aRITHABORTField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ARITHABORTSpecified { + get { + return this.aRITHABORTFieldSpecified; + } + set { + this.aRITHABORTFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool CONCAT_NULL_YIELDS_NULL { + get { + return this.cONCAT_NULL_YIELDS_NULLField; + } + set { + this.cONCAT_NULL_YIELDS_NULLField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool CONCAT_NULL_YIELDS_NULLSpecified { + get { + return this.cONCAT_NULL_YIELDS_NULLFieldSpecified; + } + set { + this.cONCAT_NULL_YIELDS_NULLFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool NUMERIC_ROUNDABORT { + get { + return this.nUMERIC_ROUNDABORTField; + } + set { + this.nUMERIC_ROUNDABORTField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool NUMERIC_ROUNDABORTSpecified { + get { + return this.nUMERIC_ROUNDABORTFieldSpecified; + } + set { + this.nUMERIC_ROUNDABORTFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool QUOTED_IDENTIFIER { + get { + return this.qUOTED_IDENTIFIERField; + } + set { + this.qUOTED_IDENTIFIERField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool QUOTED_IDENTIFIERSpecified { + get { + return this.qUOTED_IDENTIFIERFieldSpecified; + } + set { + this.qUOTED_IDENTIFIERFieldSpecified = value; + } + } + } + + /// + [System.Xml.Serialization.XmlIncludeAttribute(typeof(StmtReceiveType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(StmtCursorType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(StmtCondType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(StmtUseDbType))] + [System.Xml.Serialization.XmlIncludeAttribute(typeof(StmtSimpleType))] + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class BaseStmtInfoType { + + private SetOptionsType statementSetOptionsField; + + private int statementCompIdField; + + private bool statementCompIdFieldSpecified; + + private double statementEstRowsField; + + private bool statementEstRowsFieldSpecified; + + private int statementIdField; + + private bool statementIdFieldSpecified; + + private string statementOptmLevelField; + + private BaseStmtInfoTypeStatementOptmEarlyAbortReason statementOptmEarlyAbortReasonField; + + private bool statementOptmEarlyAbortReasonFieldSpecified; + + private string cardinalityEstimationModelVersionField; + + private double statementSubTreeCostField; + + private bool statementSubTreeCostFieldSpecified; + + private string statementTextField; + + private string statementTypeField; + + private string templatePlanGuideDBField; + + private string templatePlanGuideNameField; + + private string planGuideDBField; + + private string planGuideNameField; + + private string parameterizedTextField; + + private string parameterizedPlanHandleField; + + private string queryHashField; + + private string queryPlanHashField; + + private string retrievedFromCacheField; + + private string statementSqlHandleField; + + private ulong databaseContextSettingsIdField; + + private bool databaseContextSettingsIdFieldSpecified; + + private ulong parentObjectIdField; + + private bool parentObjectIdFieldSpecified; + + private string batchSqlHandleField; + + private int statementParameterizationTypeField; + + private bool statementParameterizationTypeFieldSpecified; + + private bool securityPolicyAppliedField; + + private bool securityPolicyAppliedFieldSpecified; + + private bool batchModeOnRowStoreUsedField; + + private bool batchModeOnRowStoreUsedFieldSpecified; + + /// + public SetOptionsType StatementSetOptions { + get { + return this.statementSetOptionsField; + } + set { + this.statementSetOptionsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int StatementCompId { + get { + return this.statementCompIdField; + } + set { + this.statementCompIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StatementCompIdSpecified { + get { + return this.statementCompIdFieldSpecified; + } + set { + this.statementCompIdFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double StatementEstRows { + get { + return this.statementEstRowsField; + } + set { + this.statementEstRowsField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StatementEstRowsSpecified { + get { + return this.statementEstRowsFieldSpecified; + } + set { + this.statementEstRowsFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int StatementId { + get { + return this.statementIdField; + } + set { + this.statementIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StatementIdSpecified { + get { + return this.statementIdFieldSpecified; + } + set { + this.statementIdFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string StatementOptmLevel { + get { + return this.statementOptmLevelField; + } + set { + this.statementOptmLevelField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public BaseStmtInfoTypeStatementOptmEarlyAbortReason StatementOptmEarlyAbortReason { + get { + return this.statementOptmEarlyAbortReasonField; + } + set { + this.statementOptmEarlyAbortReasonField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StatementOptmEarlyAbortReasonSpecified { + get { + return this.statementOptmEarlyAbortReasonFieldSpecified; + } + set { + this.statementOptmEarlyAbortReasonFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string CardinalityEstimationModelVersion { + get { + return this.cardinalityEstimationModelVersionField; + } + set { + this.cardinalityEstimationModelVersionField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public double StatementSubTreeCost { + get { + return this.statementSubTreeCostField; + } + set { + this.statementSubTreeCostField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StatementSubTreeCostSpecified { + get { + return this.statementSubTreeCostFieldSpecified; + } + set { + this.statementSubTreeCostFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string StatementText { + get { + return this.statementTextField; + } + set { + this.statementTextField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string StatementType { + get { + return this.statementTypeField; + } + set { + this.statementTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string TemplatePlanGuideDB { + get { + return this.templatePlanGuideDBField; + } + set { + this.templatePlanGuideDBField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string TemplatePlanGuideName { + get { + return this.templatePlanGuideNameField; + } + set { + this.templatePlanGuideNameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string PlanGuideDB { + get { + return this.planGuideDBField; + } + set { + this.planGuideDBField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string PlanGuideName { + get { + return this.planGuideNameField; + } + set { + this.planGuideNameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string ParameterizedText { + get { + return this.parameterizedTextField; + } + set { + this.parameterizedTextField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string ParameterizedPlanHandle { + get { + return this.parameterizedPlanHandleField; + } + set { + this.parameterizedPlanHandleField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string QueryHash { + get { + return this.queryHashField; + } + set { + this.queryHashField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string QueryPlanHash { + get { + return this.queryPlanHashField; + } + set { + this.queryPlanHashField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string RetrievedFromCache { + get { + return this.retrievedFromCacheField; + } + set { + this.retrievedFromCacheField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string StatementSqlHandle { + get { + return this.statementSqlHandleField; + } + set { + this.statementSqlHandleField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong DatabaseContextSettingsId { + get { + return this.databaseContextSettingsIdField; + } + set { + this.databaseContextSettingsIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool DatabaseContextSettingsIdSpecified { + get { + return this.databaseContextSettingsIdFieldSpecified; + } + set { + this.databaseContextSettingsIdFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ulong ParentObjectId { + get { + return this.parentObjectIdField; + } + set { + this.parentObjectIdField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool ParentObjectIdSpecified { + get { + return this.parentObjectIdFieldSpecified; + } + set { + this.parentObjectIdFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string BatchSqlHandle { + get { + return this.batchSqlHandleField; + } + set { + this.batchSqlHandleField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public int StatementParameterizationType { + get { + return this.statementParameterizationTypeField; + } + set { + this.statementParameterizationTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool StatementParameterizationTypeSpecified { + get { + return this.statementParameterizationTypeFieldSpecified; + } + set { + this.statementParameterizationTypeFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool SecurityPolicyApplied { + get { + return this.securityPolicyAppliedField; + } + set { + this.securityPolicyAppliedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool SecurityPolicyAppliedSpecified { + get { + return this.securityPolicyAppliedFieldSpecified; + } + set { + this.securityPolicyAppliedFieldSpecified = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public bool BatchModeOnRowStoreUsed { + get { + return this.batchModeOnRowStoreUsedField; + } + set { + this.batchModeOnRowStoreUsedField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool BatchModeOnRowStoreUsedSpecified { + get { + return this.batchModeOnRowStoreUsedFieldSpecified; + } + set { + this.batchModeOnRowStoreUsedFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum BaseStmtInfoTypeStatementOptmEarlyAbortReason { + + /// + TimeOut, + + /// + MemoryLimitExceeded, + + /// + GoodEnoughPlanFound, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StmtReceiveType : BaseStmtInfoType { + + private ReceivePlanTypeOperation[] receivePlanField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("Operation", IsNullable=false)] + public ReceivePlanTypeOperation[] ReceivePlan { + get { + return this.receivePlanField; + } + set { + this.receivePlanField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class ReceivePlanTypeOperation { + + private QueryPlanType queryPlanField; + + private ReceivePlanTypeOperationOperationType operationTypeField; + + private bool operationTypeFieldSpecified; + + /// + public QueryPlanType QueryPlan { + get { + return this.queryPlanField; + } + set { + this.queryPlanField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public ReceivePlanTypeOperationOperationType OperationType { + get { + return this.operationTypeField; + } + set { + this.operationTypeField = value; + } + } + + /// + [System.Xml.Serialization.XmlIgnoreAttribute()] + public bool OperationTypeSpecified { + get { + return this.operationTypeFieldSpecified; + } + set { + this.operationTypeFieldSpecified = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public enum ReceivePlanTypeOperationOperationType { + + /// + ReceivePlanSelect, + + /// + ReceivePlanUpdate, + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StmtCursorType : BaseStmtInfoType { + + private CursorPlanType cursorPlanField; + + /// + public CursorPlanType CursorPlan { + get { + return this.cursorPlanField; + } + set { + this.cursorPlanField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StmtCondType : BaseStmtInfoType { + + private StmtCondTypeCondition conditionField; + + private StmtCondTypeThen thenField; + + private StmtCondTypeElse elseField; + + /// + public StmtCondTypeCondition Condition { + get { + return this.conditionField; + } + set { + this.conditionField = value; + } + } + + /// + public StmtCondTypeThen Then { + get { + return this.thenField; + } + set { + this.thenField = value; + } + } + + /// + public StmtCondTypeElse Else { + get { + return this.elseField; + } + set { + this.elseField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StmtCondTypeCondition { + + private QueryPlanType queryPlanField; + + private FunctionType[] uDFField; + + /// + public QueryPlanType QueryPlan { + get { + return this.queryPlanField; + } + set { + this.queryPlanField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("UDF")] + public FunctionType[] UDF { + get { + return this.uDFField; + } + set { + this.uDFField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StmtCondTypeThen { + + private StmtBlockType statementsField; + + /// + public StmtBlockType Statements { + get { + return this.statementsField; + } + set { + this.statementsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StmtCondTypeElse { + + private StmtBlockType statementsField; + + /// + public StmtBlockType Statements { + get { + return this.statementsField; + } + set { + this.statementsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.microsoft.com/sqlserver/2004/07/showplan")] + public partial class StmtUseDbType : BaseStmtInfoType { + + private string databaseField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string Database { + get { + return this.databaseField; + } + set { + this.databaseField = value; + } + } + } +} diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/showplanxml.xsd b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/showplanxml.xsd new file mode 100644 index 00000000..0e98a51d --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanGraph/showplanxml.xsd @@ -0,0 +1,2482 @@ + + + + + The following schema for Microsoft SQL Server describes output from the + showplan functionality in XML format. + + Microsoft does not make any representation or warranty regarding the + schema or any product or item developed based on the schema. The schema + is provided to you on an AS IS basis. Microsoft disclaims all express, + implied and statutory warranties, including but not limited to the implied + warranties of merchantability, fitness for a particular purpose, and freedom + from infringement. Without limiting the generality of the foregoing, + Microsoft does not make any warranty of any kind that any item developed + based on the schema, or any portion of the schema, will not infringe any + copyright, patent, trade secret, or other intellectual property right of any + person or entity in any country. It is your responsibility to seek licenses + for such intellectual property rights where appropriate. + + MICROSOFT SHALL NOT BE LIABLE FOR ANY DAMAGES OF ANY KIND ARISING OUT OF OR + IN CONNECTION WITH THE USE OF THE SCHEMA, INCLUDING WITHOUT LIMITATION, ANY + DIRECT, INDIRECT, INCIDENTAL, CONSEQUENTIAL (INCLUDING ANY LOST PROFITS), + PUNITIVE OR SPECIAL DAMAGES, WHETHER OR NOT MICROSOFT HAS BEEN ADVISED OF + SUCH DAMAGES. + + + (c) Microsoft Corporation. All rights reserved. + + + + + Last updated: 09/1/2020 + + + + + This is the root element + + + + + + + + + + + + + + + + + + + + + + + + This is only found in the serialized xml for Gen3 external distributed statements. + + + + + + + + + + + The statement block that contains many statements + + + + + + + + + + + + + + + the type that contains the basic statement information + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The simple statement that may or may not contain query plan, UDF plan, Stored Procedure plan or dispatcher for parameter sensitive plan. + + + + + + + + + + + + + + + Use database statement + + + + + + + + + + + + Complex statement type that is constructed by a condition, a then clause and an optional else clause. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The cursor type that might have one or more cursor operations, used in DECLARE CURSOR, OPEN CURSOR and FETCH CURSOR + + + + + + + + + + + + The cursor type that might have one or more cursor operations, used in DECLARE CURSOR, OPEN CURSOR and FETCH CURSOR + + + + + + + + + + + + Shows the plan for the UDF or stored procedure + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The number of occur time depends on how we define the cursor + schema. In shiloh, the OPEN CURSOR and FETCH CURSOR doesn't show any plan and won't raise + error if the cursor doesn't exist. So we must keep the same behaivor, so the minOccurs is 0. If we allow + the declare cursor to be executed in showplan mode, then the open cursor and declare cursor will have + plan in showplan mode, the minOccurs will be 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Spill warning information + + + + + + + + + + Sort spill details + + + + + + + + + + + + Hash spill details + + + + + + + + + + + + Exchange spill details + + + + + + + + + Query wait information + + + + + + + + + + + + + + + + + + Wait statistics during one query execution. + WaitType: Name of the wait + WaitTimeMs: Wait time in milliseconds + WaitCount: Number of waits + + + + + + + + + A list of query wait statistics. + + + + + + + + + Shows time statistics for single query execution. + CpuTime: CPU time in milliseconds + ElapsedTime: elapsed time in milliseconds + UdfCpuTime: Cpu time of UDF in milliseconds + UdfElapsedTime: Elapsed time of UDF in milliseconds + + + + + + + + + + Warning information for plan-affecting type conversion + + + + + + + + + + + + + + + + + + List of all possible iterator or query specific warnings (e.g. hash spilling, no join predicate) + + + + + + + + + + + + + + + + + + + + + Spill Warning for last query plan stats + + + + + + For memory consuming relational operators, show fraction of memory grant iterator will use + + + + + + + + + Provide memory grant estimate as well as actual runtime memory grant information. + Serial required/desired memory attributes are estimated during query compile time for serial execution. + The rest of attributes provide estimates and counters for query execution time considering actual degree of parallelism. + SerialRequiredMemory: Required memory in KB if the query runs in serial mode. The query will not start without this memory. + SerialDesiredMemory: Memory estimated to fit intermediate results in KB if the query runs in serial mode. + RequiredMemory: Required memory in KB for the chosen degree of parallelism. If the query runs in serial mode, this is the same as SerialRequiredMemory. + DesiredMemory: Memory estimated to fit intermediate results in KB for the chosen degree of parallelism. If the query runs in serial mode, this is the same as SerialDesiredMemory. + RequestedMemory: Memory in KB which the query requests the memory manager to grant. This can be smaller than sum of RequiredMemory and DesiredMemory if it exceeds the maximum allowed for single query. + GrantWaitTime: Time in seconds if the query has to wait for successful memory grant. + MaxUsedMemory: Maximum memory in KB used by the query. + MaxQueryMemory: Maximum memory in KB allowed for single query. + LastRequestedMemory: Memory in KB which was requested by the query from the memory manager during the last execution. + IsMemoryGrantFeedbackAdjusted: Information regarding if the memory grant in this plan is adjusted based on memory grant feedback. + + + + + + + + + + + + + + + + + + + Provide warning information for memory grant. + GrantWarningKind: Warning kind + RequestedMemory: Initial grant request in KB + GrantedMemory: Granted memory in KB + MaxUsedMemory: Maximum used memory grant in KB + + + + + + + + + + + + + + + + + Describe a trace flag used in SQL engine. + + + + + + + + + Collection of trace flags used in SQL engine. + + + + + + + + + + + Provide hardware-dependent properties that affect cost estimate (and hence, query plan choice), as seen by the Query Optimizer. + EstimatedAvailableMemoryGrant is an estimate of what amount of memory (KB) will be available for this query at the execution time to request a memory grant from. + EstimatedPagesCached is an estimate of how many pages of data will remain cached in the buffer pool if the query needs to read it again. + EstimatedAvailableDegreeOfParallelism is an estimate of number of CPUs that can be used to execute the query should the Query Optimizer pick a parallel plan. + MaxCompileMemory is the maximum memory in KB allowed for query optimizer to use during compilation. + + + + + + + + + + + + Information on single statistics used during query optimization. + Database : name of the database + Schema : name of the schema + Table : name of the table + Statistics : name of the statistics + ModificationCount : number of modifications since the last update + SamplingPercent : statistics sampling percentage + LastUpdate : date when the statistics was updated + + + + + + + + + + + + + + List of statistics info used during query optimization + + + + + + + + + Runtime information provided from statistics_xml for each relational iterator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Runtime partition information provided in statistics xml for each relational iterator that support partitioning + + + + + + + + + + + + + + + + + + + + Additional information about an indexed view. It includes all tables in the query that were replaced by the indexed view. + + + + + + + + Additional information about a rollup. The highest level is the number of group by columns. + + + + + + + + + A level that is output by the rollup. Level 0 is the base aggregation, equivalent to the statement without 'WITH ROLLUP'. The highest level is the grand total, or group by all. Level 0 is always output, and at least one higher level. + + + + + + Additional information about Star Join structure. + + + + + + + + + + + + + + + + Arbitrary content type + + + + + + + + + + Information on parallel thread usage. + Branches: Attribute. total number of concurrent branches of query plan. + Query would need additional worker threads of at least (Branches)* (Degree of Parallelism) + UsedThreads: Attribute maximum number of used parallel threads. This is available only for statistics XML + Then follows a list of one or more ThreadReservation elements. + + + + + + + + + + + + Information on how parallel threads are reserved on NUMA node + NodeId: ID of NUMA node where this query is chosen to run + ReservedThreads: number of reserved parallel thread on this NUMA node + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + New Runtime information: + DegreeOfParallelism + EffectiveDegreeOfParallelism: Max parallelism used by columnstore index build + MemoryGrant (in kilobytes) + + New compile time information: + mem fractions + CachedPlanSize (in kilobytes) + CompileTime (in milliseconds) + CompileCPU (in milliseconds) + CompileMemory (in kilobytes) + Parameter values used during query compilation + NonParallelPlanReason + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The Adaptive Join element replaces a adaptive concat with Hash Join and Nested loops as inputs. This element + will have 3 inputs the two children of the HJ and the inner child of the NLJ. We append the required HJ and NLJ properties to the new + AdaptiveJoin showplan element. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Typical user defined table valued function doesn't have a relational child element. If a relational child + is present then the operator is a special internal table valued function that hosts native code. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Scalar expression. If root of scalar tree contains semantically equivalent string representation of entire expression + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This is the dispatcher expression in XML format for the parameter sensitive plan. + + + + + + + + + + This contains information related to the parameter sensitive predicate: + Boundaries used to determine different ranges; + Statistics information used to compute the boundaries; + Predicate details. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + These are the logical operators to which "query" + portions of T-SQL statement are translated. Subsequent + to that translation, a physical operator is chosen for + evaluating each logical operator. The SQL Server query + optimizer uses a cost-based approach to decide which + physical operator will implement a logical operator. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Each of the physical operator is an iterator. An iterator + can answer three method calls: Init(), GetNext(), and Close(). + Upon receiving an Init() call, an iterator initializes itself, + setting up any data structures if necessary. Upon receiving a + GetNext() call, the iterator produces the "next" packet of + data and gives it to the iterator that made the GetNext() call. + To produce the "next" packet of data, the iterator may have to + make zero or more GetNext() (or even Init()) calls to its + children. Upon receiving a Close() call, an iterator performs + some clean-up operations and shuts itself down. Typically, an + iterator receives one Init() call, followed by many GetNext() + calls, and then a single Close() call. + + The "query" portion of a T-SQL statement is typically a tree + made up of iterators. + + Usually, there is a one-to-many mapping among logical operators + and physical operators. That is, usually multiple physical operators + can implement a logical operator. In some cases in SQL Server, + however, a physical operator can implement multiple logical operators. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The set options that affects query cost + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanService.cs b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanService.cs new file mode 100644 index 00000000..fe945646 --- /dev/null +++ b/src/Microsoft.SqlTools.ServiceLayer/ShowPlan/ShowPlanService.cs @@ -0,0 +1,73 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Threading.Tasks; +using Microsoft.SqlServer.DataCollection.Common; +using Microsoft.SqlTools.Hosting.Protocol; +using Microsoft.SqlTools.ServiceLayer.Connection.Contracts; +using Microsoft.SqlTools.ServiceLayer.Connection.ReliableConnection; +using Microsoft.SqlTools.ServiceLayer.Connection; +using Microsoft.SqlTools.ServiceLayer.Hosting; + +namespace Microsoft.SqlTools.ServiceLayer.ShowPlan +{ + /// + /// Main class for Migration Service functionality + /// + public sealed class ShowPlanService : IDisposable + { + private static readonly Lazy instance = new Lazy(() => new ShowPlanService()); + + private bool disposed; + + /// + /// Construct a new MigrationService instance with default parameters + /// + public ShowPlanService() + { + } + + /// + /// Gets the singleton instance object + /// + public static ShowPlanService Instance + { + get { return instance.Value; } + } + + /// + /// Service host object for sending/receiving requests/events. + /// Internal for testing purposes. + /// + internal IProtocolEndpoint ServiceHost + { + get; + set; + } + + /// + /// Initializes the ShowPlan Service instance + /// + public void InitializeService(ServiceHost serviceHost) + { + this.ServiceHost = serviceHost; + } + + /// + /// Disposes the ShowPlan Service + /// + public void Dispose() + { + if (!disposed) + { + disposed = true; + } + } + } +} diff --git a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/Microsoft.SqlTools.ServiceLayer.UnitTests.csproj b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/Microsoft.SqlTools.ServiceLayer.UnitTests.csproj index bdd8d1ef..4c16a2dc 100644 --- a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/Microsoft.SqlTools.ServiceLayer.UnitTests.csproj +++ b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/Microsoft.SqlTools.ServiceLayer.UnitTests.csproj @@ -29,4 +29,8 @@ - \ No newline at end of file + + + + + diff --git a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/ShowPlan/ShowPlanTests.cs b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/ShowPlan/ShowPlanTests.cs new file mode 100644 index 00000000..3145bb13 --- /dev/null +++ b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/ShowPlan/ShowPlanTests.cs @@ -0,0 +1,32 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +using System.IO; +using System.Reflection; +using System.Threading.Tasks; +using NUnit.Framework; +using Microsoft.SqlTools.ServiceLayer.ShowPlan.ShowPlanGraph; + + +namespace Microsoft.SqlTools.ServiceLayer.UnitTests.ShowPlan +{ + public class ShowPlanXMLTests + { + [Test] + public async Task ParseXMLFileReturnsValidShowPlanGraph() + { + Assembly assembly = Assembly.GetAssembly(typeof(ShowPlanXMLTests)); + Stream scriptStream = assembly.GetManifestResourceStream(assembly.GetName().Name + ".ShowPlan.TestExecutionPlan.xml"); + StreamReader reader = new StreamReader(scriptStream); + string text = reader.ReadToEnd(); + var showPlanGraphs = ShowPlanGraph.ParseShowPlanXML(text, ShowPlanType.Actual); + Assert.AreEqual(1, showPlanGraphs.Length, "Single show plan graph not generated from the test xml file"); + var testShowPlanGraph = showPlanGraphs[0]; + Assert.NotNull(testShowPlanGraph, "graph should not be null"); + Assert.NotNull(testShowPlanGraph.Root, "graph should have a root"); + } + } +} \ No newline at end of file diff --git a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/ShowPlan/TestExecutionPlan.xml b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/ShowPlan/TestExecutionPlan.xml new file mode 100644 index 00000000..87cfb55b --- /dev/null +++ b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/ShowPlan/TestExecutionPlan.xml @@ -0,0 +1,6860 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file