private void CreateAggregates(List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo> aggDefs) { if (aggDefs == null || 0 >= aggDefs.Count) { return; } AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl; for (int i = 0; i < aggDefs.Count; i++) { Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo dataAggregateInfo = aggDefs[i]; Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj dataAggregateObj = aggregatesImpl.GetAggregateObj(dataAggregateInfo.Name); if (dataAggregateObj == null) { dataAggregateObj = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj(dataAggregateInfo, m_odpContext); aggregatesImpl.Add(dataAggregateObj); } if (Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Previous != dataAggregateInfo.AggregateType) { if (Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Aggregate == dataAggregateInfo.AggregateType) { RuntimeDataRegionObj.AddAggregate(ref m_customAggregates, dataAggregateObj); } else { RuntimeDataRegionObj.AddAggregate(ref m_nonCustomAggregates, dataAggregateObj); } } } }
public override void UpdateAggregates(AggregateUpdateContext context) { SetupEnvironment(); if (RuntimeDataRegionObj.UpdateAggregatesAtScope(context, this, m_dataRegionDef.DataScopeInfo, AggregateUpdateFlags.Both, needsSetupEnvironment: false)) { Traverse(ProcessingStages.UpdateAggregates, context); } }
public IReference <IDataCorrelation> GetIdcReceiver(IRIFReportDataScope scope) { if (scope.IsGroup) { Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember = scope as Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode; IReference <RuntimeMemberObj>[] memberCollection = GetMemberCollection(rifMember); return(RuntimeDataRegionObj.GetGroupRoot(rifMember, memberCollection)); } Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion rifDataRegion = scope as Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion; return(GetNestedDataRegion(rifDataRegion)); }
internal RuntimeDataTablixObj(IReference <IScope> outerScope, Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion dataTablixDef, ref DataActions dataAction, OnDemandProcessingContext odpContext, bool onePassProcess, Microsoft.ReportingServices.ReportProcessing.ObjectType objectType) : base(outerScope, dataTablixDef, ref dataAction, odpContext, onePassProcess, dataTablixDef.RunningValues, objectType, outerScope.Value().Depth + 1) { ConstructorHelper(ref dataAction, onePassProcess, out bool handleMyDataAction, out DataActions innerDataAction); m_innerDataAction = innerDataAction; DataActions userSortDataAction = HandleSortFilterEvent(); ConstructRuntimeStructure(ref innerDataAction, onePassProcess); HandleDataAction(handleMyDataAction, innerDataAction, userSortDataAction); m_odpContext.CreatedScopeInstance(m_dataRegionDef); m_scopeInstanceNumber = RuntimeDataRegionObj.AssignScopeInstanceNumber(m_dataRegionDef.DataScopeInfo); }
private bool NextRegularRow() { if (m_odpContext.ReportObjectModel.FieldsImpl.AggregationFieldCount == 0) { m_hasProcessedAggregateRow = true; RuntimeDataRegionObj.UpdateAggregates(m_odpContext, m_customAggregates, updateAndSetup: false); } if (m_odpContext.ReportObjectModel.FieldsImpl.IsAggregateRow) { ScopeNextAggregateRow(m_userSortTargetInfo); return false; } NextNonAggregateRow(); return true; }
private void CreateCells(IReference <RuntimeDataRegionObj> containingScopeRef, OnDemandProcessingContext odpContext, DataRegionInstance dataRegionInstance, bool isOuterGroup, IReference <RuntimeDataTablixGroupRootObj> currOuterGroupRoot, ScopeInstance parentInstance, IReference <RuntimeMemberObj>[] innerMembers, IReference <RuntimeDataTablixGroupLeafObj> innerGroupLeafRef) { using (containingScopeRef.PinValue()) { RuntimeDataRegionObj runtimeDataRegionObj = containingScopeRef.Value(); if (runtimeDataRegionObj is RuntimeDataTablixGroupLeafObj) { ((RuntimeDataTablixGroupLeafObj)runtimeDataRegionObj).CreateStaticCells(dataRegionInstance, parentInstance, currOuterGroupRoot, isOuterGroup, m_staticLeafCellIndexes, innerMembers, innerGroupLeafRef); } else { ((RuntimeDataTablixObj)runtimeDataRegionObj).CreateOutermostStaticCells(dataRegionInstance, isOuterGroup, innerMembers, innerGroupLeafRef); } } }
internal override bool SortAndFilter(AggregateUpdateContext aggContext) { SetupEnvironment(); if (m_userSortTargetInfo != null) { m_userSortTargetInfo.EnterProcessUserSortPhase(m_odpContext); } bool num = base.DataRegionDef.ProcessingInnerGrouping == Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion.ProcessingInnerGroupings.Column; IReference <RuntimeMemberObj>[] array = num ? m_outerGroupings : m_innerGroupings; IReference <RuntimeMemberObj>[] array2 = num ? m_innerGroupings : m_outerGroupings; int rowDomainScopeCount = base.DataRegionDef.RowDomainScopeCount; int columnDomainScopeCount = base.DataRegionDef.ColumnDomainScopeCount; DomainScopeContext domainScopeContext = base.OdpContext.DomainScopeContext; AggregateUpdateQueue workQueue = null; if (m_odpContext.HasSecondPassOperation(SecondPassOperations.FilteringOrAggregatesOrDomainScope)) { workQueue = RuntimeDataRegionObj.AggregateOfAggregatesStart(aggContext, this, m_dataRegionDef.DataScopeInfo, m_aggregatesOfAggregates, AggregateUpdateFlags.Both, needsSetupEnvironment: false); if (rowDomainScopeCount > 0) { domainScopeContext.AddDomainScopes(array, array.Length - rowDomainScopeCount); } if (columnDomainScopeCount > 0) { domainScopeContext.AddDomainScopes(array2, array2.Length - columnDomainScopeCount); } } Traverse(ProcessingStages.SortAndFilter, aggContext); base.SortAndFilter(aggContext); if (m_odpContext.HasSecondPassOperation(SecondPassOperations.FilteringOrAggregatesOrDomainScope)) { RuntimeDataRegionObj.AggregatesOfAggregatesEnd(this, aggContext, workQueue, m_dataRegionDef.DataScopeInfo, m_aggregatesOfAggregates, updateAggsIfNeeded: true); if (rowDomainScopeCount > 0) { domainScopeContext.RemoveDomainScopes(array, array.Length - rowDomainScopeCount); } if (columnDomainScopeCount > 0) { domainScopeContext.RemoveDomainScopes(array2, array2.Length - columnDomainScopeCount); } } if (m_userSortTargetInfo != null) { m_userSortTargetInfo.LeaveProcessUserSortPhase(m_odpContext); } return(true); }
internal RuntimeRDLDataRegionObj(IReference<IScope> outerScope, Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef, ref DataActions dataAction, OnDemandProcessingContext odpContext, bool onePassProcess, List<Microsoft.ReportingServices.ReportIntermediateFormat.RunningValueInfo> runningValues, Microsoft.ReportingServices.ReportProcessing.ObjectType objectType, int level) : base(odpContext, objectType, level) { m_dataRegionDef = dataRegionDef; m_outerScope = outerScope; RuntimeDataRegionObj.CreateAggregates(m_odpContext, dataRegionDef.Aggregates, ref m_nonCustomAggregates, ref m_customAggregates); if (dataRegionDef.DataScopeInfo != null) { RuntimeDataRegionObj.CreateAggregates(m_odpContext, dataRegionDef.DataScopeInfo.AggregatesOfAggregates, ref m_aggregatesOfAggregates); } if (dataRegionDef.Filters != null) { m_filters = new Filters(Filters.FilterTypes.DataRegionFilter, (IReference<Microsoft.ReportingServices.ReportProcessing.ReportProcessing.IFilterOwner>)base.SelfReference, dataRegionDef.Filters, dataRegionDef.ObjectType, dataRegionDef.Name, m_odpContext, level + 1); return; } m_outerDataAction = dataAction; m_dataAction = dataAction; dataAction = DataActions.None; }
public override void ReadRow(DataActions dataAction, ITraversalContext context) { if (DataActions.UserSort == dataAction) { RuntimeDataRegionObj.CommonFirstRow(m_odpContext, ref m_firstRowIsAggregate, ref m_firstRow); CommonNextRow(m_dataRows); return; } if (DataActions.AggregatesOfAggregates == dataAction) { ((AggregateUpdateContext)context).UpdateAggregatesForRow(); return; } if (FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregatesOfAggregates)) { ((AggregateUpdateContext)context).UpdateAggregatesForRow(); } if (m_dataRegionDef.ProcessCellRunningValues) { return; } if (FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregates)) { if (m_postSortAggregates != null) { RuntimeDataRegionObj.UpdateAggregates(m_odpContext, m_postSortAggregates, updateAndSetup: false); } if (m_runningValues != null) { UpdateRunningValues(m_odpContext, m_runningValues); } } if (m_outerScope != null && (dataAction & m_outerDataAction) != 0) { using (m_outerScope.PinValue()) { m_outerScope.Value().ReadRow(dataAction, context); } } }
internal void RegisterSortFilterExpressionScope(IReference <IScope> containerRef, IReference <RuntimeDataRegionObj> scopeRef, bool[] isSortFilterExpressionScope) { List <IReference <RuntimeSortFilterEventInfo> > runtimeSortFilterInfo = m_runtimeSortFilterInfo; if (runtimeSortFilterInfo == null || isSortFilterExpressionScope == null || scopeRef == null) { return; } List <object>[] array = null; using (scopeRef.PinValue()) { RuntimeDataRegionObj runtimeDataRegionObj = scopeRef.Value(); using (containerRef.PinValue()) { IScope scope = containerRef.Value(); for (int i = 0; i < runtimeSortFilterInfo.Count; i++) { if (!isSortFilterExpressionScope[i] || !runtimeDataRegionObj.IsTargetForSort(i, detailSort: false) || !runtimeDataRegionObj.TargetScopeMatched(i, detailSort: false)) { continue; } IReference <RuntimeSortFilterEventInfo> reference = runtimeSortFilterInfo[i]; using (reference.PinValue()) { RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = reference.Value(); if (array == null && runtimeSortFilterEventInfo.EventSource.UserSort.GroupsInSortTarget != null) { int index = 0; array = new List <object> [runtimeSortFilterEventInfo.EventSource.UserSort.GroupsInSortTarget.Count]; runtimeDataRegionObj.GetScopeValues(runtimeSortFilterEventInfo.EventTarget, array, ref index); } runtimeSortFilterEventInfo.RegisterSortFilterExpressionScope(ref scope.SortFilterExpressionScopeInfoIndices[i], scopeRef, array, i); } } } } }
void IDataRowSortOwner.PostDataRowSortNextRow() { RuntimeDataRegionObj.CommonFirstRow(m_odpContext, ref m_firstRowIsAggregate, ref m_firstRow); ScopeNextNonAggregateRow(m_nonCustomAggregates, m_dataRows); }
public IOnDemandMemberInstanceReference GetFirstMemberInstance(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember) { IReference <RuntimeMemberObj>[] memberCollection = GetMemberCollection(rifMember); return(RuntimeDataRegionObj.GetFirstMemberInstance(rifMember, memberCollection)); }
protected void ConstructorHelper(ref DataActions dataAction, bool onePassProcess, out bool handleMyDataAction, out DataActions innerDataAction) { innerDataAction = m_dataAction; handleMyDataAction = false; if (onePassProcess) { if (m_dataRegionDef.RunningValues != null && 0 < m_dataRegionDef.RunningValues.Count) { RuntimeDataRegionObj.CreateAggregates(m_odpContext, m_dataRegionDef.RunningValues, ref m_nonCustomAggregates); } RuntimeDataRegionObj.CreateAggregates(m_odpContext, m_dataRegionDef.PostSortAggregates, ref m_nonCustomAggregates); RuntimeDataRegionObj.CreateAggregates(m_odpContext, m_dataRegionDef.CellPostSortAggregates, ref m_nonCustomAggregates); } else { if (m_dataRegionDef.RunningValues != null && 0 < m_dataRegionDef.RunningValues.Count) { m_dataAction |= DataActions.PostSortAggregates; } if (m_dataRegionDef.PostSortAggregates != null && m_dataRegionDef.PostSortAggregates.Count != 0) { RuntimeDataRegionObj.CreateAggregates(m_odpContext, m_dataRegionDef.PostSortAggregates, ref m_postSortAggregates); m_dataAction |= DataActions.PostSortAggregates; handleMyDataAction = true; } if (m_dataRegionDef.DataScopeInfo != null) { DataScopeInfo dataScopeInfo = m_dataRegionDef.DataScopeInfo; if (dataScopeInfo.PostSortAggregatesOfAggregates != null && !dataScopeInfo.PostSortAggregatesOfAggregates.IsEmpty) { RuntimeDataRegionObj.CreateAggregates(m_odpContext, dataScopeInfo.PostSortAggregatesOfAggregates, ref m_postSortAggregatesOfAggregates); } if (dataScopeInfo.HasAggregatesToUpdateAtRowScope) { m_dataAction |= DataActions.AggregatesOfAggregates; handleMyDataAction = true; } } if (handleMyDataAction) { innerDataAction = DataActions.None; } else { innerDataAction = m_dataAction; } } m_inDataRowSortPhase = (m_dataRegionDef.Sorting != null && m_dataRegionDef.Sorting.ShouldApplySorting); if (m_inDataRowSortPhase) { m_sortedDataRowTree = new BTree(this, m_odpContext, m_depth); m_dataRowSortExpression = new RuntimeExpressionInfo(m_dataRegionDef.Sorting.SortExpressions, m_dataRegionDef.Sorting.ExprHost, m_dataRegionDef.Sorting.SortDirections, 0); m_odpContext.AddSpecialDataRowSort((IReference <IDataRowSortOwner>)base.SelfReference); } m_dataRegionDef.ResetInstanceIndexes(); m_outerGroupingCounters = new int[m_dataRegionDef.OuterGroupingDynamicMemberCount]; for (int i = 0; i < m_outerGroupingCounters.Length; i++) { m_outerGroupingCounters[i] = -1; } }
internal override void CalculateRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext) { if (m_dataRegionDef.RunningValues != null && m_runningValues == null && m_previousValues == null) { AddRunningValues(m_odpContext, m_dataRegionDef.RunningValues, ref m_runningValues, ref m_previousValues, groupCol, lastGroup); } if (m_dataRegionDef.DataScopeInfo != null) { List <string> runningValuesInGroup = null; List <string> previousValuesInGroup = null; AddRunningValues(m_odpContext, m_dataRegionDef.DataScopeInfo.RunningValuesOfAggregates, ref runningValuesInGroup, ref previousValuesInGroup, groupCol, lastGroup); } bool flag = m_dataRows != null && FlagUtils.HasFlag(m_dataAction, DataActions.PostSortAggregates); AggregateUpdateQueue workQueue = RuntimeDataRegionObj.AggregateOfAggregatesStart(aggContext, this, m_dataRegionDef.DataScopeInfo, m_postSortAggregatesOfAggregates, flag ? AggregateUpdateFlags.ScopedAggregates : AggregateUpdateFlags.Both, needsSetupEnvironment: true); if (flag) { DataActions dataActions = DataActions.PostSortAggregates; if (aggContext.LastScopeNeedsRowAggregateProcessing()) { dataActions |= DataActions.PostSortAggregatesOfAggregates; } ReadRows(dataActions, aggContext); m_dataRows = null; } int num = (m_outerGroupings != null) ? m_outerGroupings.Length : 0; if (num == 0) { if (m_innerGroupings != null) { for (int i = 0; i < m_innerGroupings.Length; i++) { IReference <RuntimeMemberObj> reference = m_innerGroupings[i]; using (reference.PinValue()) { reference.Value().CalculateRunningValues(groupCol, lastGroup, aggContext); } } } } else { for (int j = 0; j < num; j++) { IReference <RuntimeMemberObj> reference2 = m_outerGroupings[j]; bool flag2; using (reference2.PinValue()) { RuntimeMemberObj runtimeMemberObj = reference2.Value(); runtimeMemberObj.CalculateRunningValues(groupCol, lastGroup, aggContext); flag2 = (runtimeMemberObj.GroupRoot == null); } if (!flag2 || m_innerGroupings == null) { continue; } for (int k = 0; k < m_innerGroupings.Length; k++) { IReference <RuntimeMemberObj> reference3 = m_innerGroupings[k]; using (reference3.PinValue()) { RuntimeMemberObj runtimeMemberObj2 = reference3.Value(); runtimeMemberObj2.PrepareCalculateRunningValues(); runtimeMemberObj2.CalculateRunningValues(groupCol, lastGroup, aggContext); } } } } CalculateRunningValuesForTopLevelStaticContents(groupCol, lastGroup, aggContext); RuntimeDataRegionObj.AggregatesOfAggregatesEnd(this, aggContext, workQueue, m_dataRegionDef.DataScopeInfo, m_postSortAggregatesOfAggregates, updateAggsIfNeeded: true); CalculateDRPreviousAggregates(); RuntimeRICollection.StoreRunningValues(m_odpContext.ReportObjectModel.AggregatesImpl, m_dataRegionDef.RunningValues, ref m_runningValueValues); if (m_dataRegionDef.DataScopeInfo != null) { RuntimeRICollection.StoreRunningValues(m_odpContext.ReportObjectModel.AggregatesImpl, m_dataRegionDef.DataScopeInfo.RunningValuesOfAggregates, ref m_runningValueOfAggregateValues); } }