internal bool SearchAndInsert(object keyValue, ScalableList <BTreeNode> nodes, IHierarchyObj owner, out BTreeNodeValue newSiblingValue, out int newSiblingIndex, out int globalNewSiblingIndex)
{
int num = -1;
int i;
for (i = 1; i < m_tuples.Count; i++)
{
num = m_tuples[i].Value.CompareTo(keyValue, owner.OdpContext);
if (num >= 0)
{
break;
}
}
if (num == 0)
{
m_tuples[i].Value.AddRow(owner);
}
else
{
int childIndex = m_tuples[i - 1].ChildIndex;
if (childIndex == -1)
{
return(InsertBTreeNode(nodes, CreateBTreeNode(keyValue, owner), i, -1, owner, out newSiblingValue, out newSiblingIndex, out globalNewSiblingIndex));
}
BTreeNode item;
using (nodes.GetAndPin(childIndex, out item))
{
if (!item.SearchAndInsert(keyValue, nodes, owner, out BTreeNodeValue newSiblingValue2, out int newSiblingIndex2, out int globalNewSiblingIndex2))
{
return(InsertBTreeNode(nodes, newSiblingValue2, newSiblingIndex2, globalNewSiblingIndex2, owner, out newSiblingValue, out newSiblingIndex, out globalNewSiblingIndex));
}
}
}
newSiblingValue = null;
newSiblingIndex = -1;
globalNewSiblingIndex = -1;
return(true);
}
public RuntimeOnDemandDataSetObj(OnDemandProcessingContext odpContext, AspNetCore.ReportingServices.ReportIntermediateFormat.DataSet dataSet, DataSetInstance dataSetInstance)
{
this.m_odpContext = odpContext;
this.m_dataSet = dataSet;
this.m_dataSetInstance = dataSetInstance;
this.m_odpContext.TablixProcessingScalabilityCache.GenerateFixedReference(this);
UserSortFilterContext userSortFilterContext = odpContext.UserSortFilterContext;
if (this.m_odpContext.IsSortFilterTarget(dataSet.IsSortFilterTarget, userSortFilterContext.CurrentContainingScope, this.SelfReference, ref this.m_userSortTargetInfo) && this.m_userSortTargetInfo.TargetForNonDetailSort)
{
this.m_dataRows = new ScalableList <DataFieldRow>(0, odpContext.TablixProcessingScalabilityCache, 100, 10);
}
if (!this.m_odpContext.StreamingMode)
{
this.CreateRuntimeStructure();
}
this.m_dataSet.SetupRuntimeEnvironment(this.m_odpContext);
if (this.m_dataSet.Filters != null)
{
this.m_filters = new Filters(Filters.FilterTypes.DataSetFilter, (IReference <AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.IFilterOwner>) this.SelfReference, this.m_dataSet.Filters, this.m_dataSet.ObjectType, this.m_dataSet.Name, this.m_odpContext, 0);
}
this.RegisterAggregates();
}
internal static void SaveData(ScalableList <DataFieldRow> dataRows, OnDemandProcessingContext odpContext)
{
Global.Tracer.Assert(dataRows != null, "(null != dataRows)");
dataRows.Add(SaveData(odpContext));
}
internal void ProcessUserSortForTarget(ObjectModelImpl reportObjectModel, Microsoft.ReportingServices.RdlExpressions.ReportRuntime reportRuntime, IReference <IHierarchyObj> target, ref ScalableList <DataFieldRow> dataRows, bool targetForNonDetailSort)
{
using (target.PinValue())
{
IHierarchyObj hierarchyObj = target.Value();
if (targetForNonDetailSort && dataRows != null && 0 < dataRows.Count)
{
IReference <RuntimeSortFilterEventInfo> reference = null;
try
{
List <int> sortFilterInfoIndices = hierarchyObj.SortFilterInfoIndices;
Global.Tracer.Assert(hierarchyObj.SortTree != null, "(null != targetObj.SortTree)");
if (sortFilterInfoIndices != null)
{
reference = m_runtimeSortFilterInfo[sortFilterInfoIndices[0]];
}
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = null;
if (reference != null)
{
reference.PinValue();
runtimeSortFilterEventInfo = reference.Value();
}
for (int i = 0; i < dataRows.Count; i++)
{
dataRows[i].SetFields(reportObjectModel.FieldsImpl);
object keyValue = DBNull.Value;
if (runtimeSortFilterEventInfo != null)
{
keyValue = runtimeSortFilterEventInfo.GetSortOrder(reportRuntime);
}
hierarchyObj.SortTree.NextRow(keyValue, hierarchyObj);
}
}
finally
{
reference?.UnPinValue();
}
if (dataRows != null)
{
dataRows.Dispose();
}
dataRows = null;
}
hierarchyObj.MarkSortInfoProcessed(m_runtimeSortFilterInfo);
}
}
protected void ScopeNextNonAggregateRow(List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj> aggregates, ScalableList <DataFieldRow> dataRows)
{
UpdateAggregates(m_odpContext, aggregates, updateAndSetup: true);
CommonNextRow(dataRows);
}
public void Dispose()
{
m_rows.Dispose();
m_rows = null;
}
internal CommonRowCache(IScalabilityCache scaleCache)
{
m_rows = new ScalableList <DataFieldRow>(0, scaleCache, 1000, 100);
}
internal RuntimeCells(int priority, IScalabilityCache cache)
{
m_collection = new ScalableList<IStorable>(priority, cache, 200, 10);
}
public override void Deserialize(IntermediateFormatReader reader)
{
base.Deserialize(reader);
reader.RegisterDeclaration(m_Declaration);
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.ID:
m_memberDef = reader.ReadGlobalReference <ReportHierarchyNode>();
break;
case MemberName.MemberInstanceIndexWithinScopeLevel:
m_memberInstanceIndexWithinScopeLevel = reader.Read7BitEncodedInt();
break;
case MemberName.Children:
m_children = reader.ReadGenericListOfRIFObjectsUsingNew <ScalableList <DataRegionMemberInstance> >();
SetReadOnlyList(m_children);
break;
case MemberName.Cells2:
m_cells = reader.ReadRIFObject <ScalableList <DataCellInstanceList> >();
break;
case MemberName.Cells:
m_upgradedSnapshotCells = reader.ReadGenericListOfRIFObjectsUsingNew <ScalableList <DataCellInstance> >();
SetReadOnlyList(m_upgradedSnapshotCells);
break;
case MemberName.Variables:
m_variables = reader.ReadVariantArray();
break;
case MemberName.SerializableVariables:
m_variables = reader.ReadSerializableArray();
break;
case MemberName.RecursiveLevel:
m_recursiveLevel = reader.Read7BitEncodedInt();
break;
case MemberName.GroupExpressionValues:
m_groupExprValues = reader.ReadVariantArray();
break;
case MemberName.ParentInstanceIndex:
m_parentInstanceIndex = reader.ReadInt32();
break;
case MemberName.HasRecursiveChildren:
{
object obj = reader.ReadVariant();
if (obj != null)
{
m_hasRecursiveChildren = (bool)obj;
}
break;
}
default:
Global.Tracer.Assert(condition: false);
break;
}
}
}
public static void SaveData(ScalableList <DataFieldRow> dataRows, OnDemandProcessingContext odpContext)
{
Global.Tracer.Assert(null != dataRows, "(null != dataRows)");
dataRows.Add(RuntimeDataTablixObj.SaveData(odpContext));
}
public void Dispose()
{
this.m_rows.Dispose();
this.m_rows = null;
}
public CommonRowCache(IScalabilityCache scaleCache)
{
this.m_rows = new ScalableList <DataFieldRow>(0, scaleCache, 1000, 100);
}
private bool InsertBTreeNode(ScalableList <BTreeNode> nodes, BTreeNodeValue nodeValueToInsert, int nodeIndexToInsert, int globalNodeIndexToInsert, IHierarchyObj owner, out BTreeNodeValue newSiblingValue, out int newSiblingIndex, out int globalNewSibingIndex)
{
if (3 > m_tuples.Count)
{
m_tuples.Insert(nodeIndexToInsert, new BTreeNodeTuple(nodeValueToInsert, globalNodeIndexToInsert), nodes);
newSiblingValue = null;
newSiblingIndex = -1;
globalNewSibingIndex = -1;
return(true);
}
int num = 2;
BTreeNode bTreeNode = new BTreeNode(owner);
BTreeNodeValue bTreeNodeValue;
if (num < nodeIndexToInsert)
{
bTreeNodeValue = m_tuples[num].Value;
bTreeNode.SetFirstChild(nodes, m_tuples[num].ChildIndex);
for (int i = num + 1; i < ((m_tuples.Count <= nodeIndexToInsert) ? m_tuples.Count : nodeIndexToInsert); i++)
{
bTreeNode.m_tuples.Add(m_tuples[i], nodes);
}
bTreeNode.m_tuples.Add(new BTreeNodeTuple(nodeValueToInsert, globalNodeIndexToInsert), nodes);
for (int j = nodeIndexToInsert; j < m_tuples.Count; j++)
{
bTreeNode.m_tuples.Add(m_tuples[j], nodes);
}
int count = m_tuples.Count;
for (int k = num; k < count; k++)
{
m_tuples.RemoveAtEnd();
}
}
else if (num > nodeIndexToInsert)
{
bTreeNodeValue = m_tuples[num - 1].Value;
bTreeNode.SetFirstChild(nodes, m_tuples[num - 1].ChildIndex);
for (int l = num; l < m_tuples.Count; l++)
{
bTreeNode.m_tuples.Add(m_tuples[l], nodes);
}
int count2 = m_tuples.Count;
for (int m = num - 1; m < count2; m++)
{
m_tuples.RemoveAtEnd();
}
m_tuples.Insert(nodeIndexToInsert, new BTreeNodeTuple(nodeValueToInsert, globalNodeIndexToInsert), nodes);
}
else
{
bTreeNodeValue = nodeValueToInsert;
bTreeNode.SetFirstChild(nodes, globalNodeIndexToInsert);
for (int n = num; n < m_tuples.Count; n++)
{
bTreeNode.m_tuples.Add(m_tuples[n], nodes);
}
int count3 = m_tuples.Count;
for (int num2 = num; num2 < count3; num2++)
{
m_tuples.RemoveAtEnd();
}
}
newSiblingValue = bTreeNodeValue;
newSiblingIndex = m_indexInParent + 1;
globalNewSibingIndex = nodes.Count;
nodes.Add(bTreeNode);
return(false);
}
public override void Deserialize(IntermediateFormatReader reader)
{
base.Deserialize(reader);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
reader.RegisterDeclaration(m_declaration);
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.HierarchyDef:
{
int id2 = reader.ReadInt32();
m_hierarchyDef = (Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode)scalabilityCache.FetchStaticReference(id2);
break;
}
case MemberName.OuterScope:
m_outerScope = (IReference <IScope>)reader.ReadRIFObject();
break;
case MemberName.ProcessingStage:
m_processingStage = (ProcessingStages)reader.ReadEnum();
break;
case MemberName.ScopedRunningValues:
m_scopedRunningValues = reader.ReadListOfPrimitives <string>();
break;
case MemberName.RunningValuesInGroup:
m_runningValuesInGroup = reader.ReadListOfPrimitives <string>();
break;
case MemberName.PreviousValuesInGroup:
m_previousValuesInGroup = reader.ReadListOfPrimitives <string>();
break;
case MemberName.GroupCollection:
m_groupCollection = reader.ReadStringRIFObjectDictionary <IReference <RuntimeGroupRootObj> >();
break;
case MemberName.DataAction:
m_dataAction = (DataActions)reader.ReadEnum();
break;
case MemberName.OuterDataAction:
m_outerDataAction = (DataActions)reader.ReadEnum();
break;
case MemberName.GroupingType:
m_groupingType = (RuntimeGroupingObj.GroupingTypes)reader.ReadEnum();
break;
case MemberName.Filters:
{
int id = reader.ReadInt32();
m_groupFilters = (Filters)scalabilityCache.FetchStaticReference(id);
break;
}
case MemberName.ParentExpression:
m_parentExpression = (RuntimeExpressionInfo)reader.ReadRIFObject();
break;
case MemberName.CurrentGroupExprValue:
m_currentGroupExprValue = reader.ReadVariant();
break;
case MemberName.SaveGroupExprValues:
m_saveGroupExprValues = reader.ReadBoolean();
break;
case MemberName.SortFilterExpressionScopeInfoIndices:
m_sortFilterExpressionScopeInfoIndices = reader.ReadInt32Array();
break;
case MemberName.BuiltinSortOverridden:
m_builtinSortOverridden = reader.ReadBooleanArray();
break;
case MemberName.IsDetailGroup:
m_isDetailGroup = reader.ReadBoolean();
break;
case MemberName.DetailUserSortTargetInfo:
m_detailUserSortTargetInfo = (RuntimeUserSortTargetInfo)reader.ReadRIFObject();
break;
case MemberName.DetailRows:
m_detailDataRows = reader.ReadRIFObject <ScalableList <DataFieldRow> >();
break;
default:
Global.Tracer.Assert(condition: false);
break;
}
}
}
protected void ScopeNextNonAggregateRow(List <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj> aggregates, ScalableList <DataFieldRow> dataRows)
{
RuntimeDataRegionObj.UpdateAggregates(this.m_odpContext, aggregates, true);
this.CommonNextRow(dataRows);
}
internal BTree(IHierarchyObj owner, OnDemandProcessingContext odpContext, int level)
{
m_nodes = new ScalableList <BTreeNode>(level, odpContext.TablixProcessingScalabilityCache);
m_root = new BTreeNode(owner);
}
protected void ReleaseDataRows(DataActions finishedDataAction, ref DataActions dataAction, ref ScalableList <DataFieldRow> dataRows)
{
dataAction &= ~finishedDataAction;
if (dataAction == DataActions.None)
{
dataRows.Clear();
dataRows = null;
}
}
public void Dispose()
{
m_nodes.Dispose();
m_nodes = null;
}
public override void Deserialize(IntermediateFormatReader reader)
{
base.Deserialize(reader);
reader.RegisterDeclaration(m_declaration);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.DataRegionDef:
{
int id2 = reader.ReadInt32();
m_dataRegionDef = (Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion)scalabilityCache.FetchStaticReference(id2);
break;
}
case MemberName.OuterScope:
m_outerScope = (IReference<IScope>)reader.ReadRIFObject();
break;
case MemberName.FirstRow:
m_firstRow = (DataFieldRow)reader.ReadRIFObject();
break;
case MemberName.FirstRowIsAggregate:
m_firstRowIsAggregate = reader.ReadBoolean();
break;
case MemberName.Filters:
{
int id = reader.ReadInt32();
m_filters = (Filters)scalabilityCache.FetchStaticReference(id);
break;
}
case MemberName.NonCustomAggregates:
m_nonCustomAggregates = reader.ReadListOfRIFObjects<List<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj>>();
break;
case MemberName.CustomAggregates:
m_customAggregates = reader.ReadListOfRIFObjects<List<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj>>();
break;
case MemberName.DataAction:
m_dataAction = (DataActions)reader.ReadEnum();
break;
case MemberName.OuterDataAction:
m_outerDataAction = (DataActions)reader.ReadEnum();
break;
case MemberName.RunningValues:
m_runningValues = reader.ReadListOfPrimitives<string>();
break;
case MemberName.PreviousValues:
m_previousValues = reader.ReadListOfPrimitives<string>();
break;
case MemberName.RunningValueValues:
m_runningValueValues = reader.ReadArrayOfRIFObjects<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult>();
break;
case MemberName.RunningValueOfAggregateValues:
m_runningValueOfAggregateValues = reader.ReadArrayOfRIFObjects<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult>();
break;
case MemberName.PostSortAggregates:
m_postSortAggregates = reader.ReadListOfRIFObjects<List<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj>>();
break;
case MemberName.DataRows:
m_dataRows = reader.ReadRIFObject<ScalableList<DataFieldRow>>();
break;
case MemberName.InnerDataAction:
m_innerDataAction = (DataActions)reader.ReadEnum();
break;
case MemberName.UserSortTargetInfo:
m_userSortTargetInfo = (RuntimeUserSortTargetInfo)reader.ReadRIFObject();
break;
case MemberName.SortFilterExpressionScopeInfoIndices:
m_sortFilterExpressionScopeInfoIndices = reader.ReadInt32Array();
break;
case MemberName.InDataRowSortPhase:
m_inDataRowSortPhase = reader.ReadBoolean();
break;
case MemberName.SortedDataRowTree:
m_sortedDataRowTree = (BTree)reader.ReadRIFObject();
break;
case MemberName.DataRowSortExpression:
m_dataRowSortExpression = (RuntimeExpressionInfo)reader.ReadRIFObject();
break;
case MemberName.AggregatesOfAggregates:
m_aggregatesOfAggregates = (BucketedDataAggregateObjs)reader.ReadRIFObject();
break;
case MemberName.PostSortAggregatesOfAggregates:
m_postSortAggregatesOfAggregates = (BucketedDataAggregateObjs)reader.ReadRIFObject();
break;
case MemberName.HasProcessedAggregateRow:
m_hasProcessedAggregateRow = reader.ReadBoolean();
break;
default:
Global.Tracer.Assert(condition: false);
break;
}
}
}
public void Dispose()
{
this.m_nodes.Dispose();
this.m_nodes = null;
}
