private bool SetupNextRow()
{
try
{
m_currentRow = ReadOneRow(out int rowIndex);
if (m_currentRow == null)
{
return(false);
}
FieldsImpl fieldsImpl = m_odpContext.ReportObjectModel.FieldsImpl;
fieldsImpl.NewRow();
if (fieldsImpl.AddRowIndex)
{
fieldsImpl.SetRowIndex(rowIndex);
}
m_odpContext.ReportObjectModel.UpdateFieldValues(reuseFieldObjects: false, m_currentRow, m_dataSetInstance, base.HasServerAggregateMetadata);
return(true);
}
catch (Exception)
{
CleanupForException();
FinalCleanup();
throw;
}
}
internal RecordRow(RecordRow original, int[] mappingDataSetFieldIndexesToDataChunk)
{
m_streamPosition = original.m_streamPosition;
m_isAggregateRow = original.m_isAggregateRow;
m_recordFields = original.m_recordFields;
ApplyFieldMapping(mappingDataSetFieldIndexesToDataChunk);
}
protected Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow ReadOneRow(out int rowIndex)
{
Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow result = null;
rowIndex = -1;
if (m_allDataRowsRead)
{
return(result);
}
do
{
bool flag = m_dataReader != null && m_dataReader.GetNextRow();
if (m_dataRowsRead == 0)
{
InitializeBeforeFirstRow(flag);
}
if (flag)
{
m_odpContext.CheckAndThrowIfAborted();
result = ReadRow();
rowIndex = m_dataRowsRead;
IncrementRowCounterAndTrace();
}
else
{
result = null;
m_allDataRowsRead = true;
}
}while (!m_allDataRowsRead && m_restartPosition != null && m_restartPosition.ShouldSkip(m_odpContext, result));
if (m_restartPosition != null)
{
m_restartPosition.DisableRowSkipping(result);
}
return(result);
}
private bool FetchSharedDataSetCached()
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataSet dataSet = new Microsoft.ReportingServices.ReportIntermediateFormat.DataSet(m_dataSetDefinition.DataSetCore);
ProcessingDataReader processingDataReader = new ProcessingDataReader(new DataSetInstance(dataSet), dataSet, m_odpContext, overrideWithSharedDataSetChunkSettings: true);
IRowConsumer consumerRequest = m_odpContext.ExternalDataSetContext.ConsumerRequest;
consumerRequest.SetProcessingDataReader(processingDataReader);
long num = 0L;
try
{
while (processingDataReader.GetNextRow())
{
Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow underlyingRecordRowObject = processingDataReader.GetUnderlyingRecordRowObject();
consumerRequest.NextRow(underlyingRecordRowObject);
num++;
}
}
finally
{
if (m_odpContext.JobContext != null)
{
lock (m_odpContext.JobContext.SyncRoot)
{
m_odpContext.JobContext.RowCount += num;
}
}
}
return(true);
}
protected override void ProcessRow(Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow row, int rowNumber)
{
if (m_processFromLiveDataReader && !m_dataSet.IsReferenceToSharedDataSet)
{
base.ProcessRow(row, rowNumber);
}
m_dataProcessingController.NextRow(row, rowNumber, m_processFromLiveDataReader && !m_canWriteDataChunk, base.HasServerAggregateMetadata);
}
protected void ProcessRows()
{
int rowIndex;
for (Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow recordRow = ReadOneRow(out rowIndex); recordRow != null; recordRow = ReadOneRow(out rowIndex))
{
ProcessRow(recordRow, rowIndex);
}
}
protected override void ProcessRow(Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow row, int rowNumber)
{
if (m_mustEvaluateThroughReportObjectModel)
{
base.ProcessRow(row, rowNumber);
return;
}
m_currentRow = row;
PostFilterNextRow();
}
internal void UpdateRecordRow(Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow recordRow)
{
m_recordRow = recordRow;
if (m_fields != null)
{
for (int i = 0; i < m_fields.Length; i++)
{
m_fields[i]?.UpdateRecordField(m_recordRow.RecordFields[i]);
}
}
}
private Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow ReadRow()
{
_ = m_dataSet.Fields.Count;
Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow underlyingRecordRowObject = m_dataReader.GetUnderlyingRecordRowObject();
if (underlyingRecordRowObject != null)
{
return(underlyingRecordRowObject);
}
m_executionMetrics.StartTotalTimer();
underlyingRecordRowObject = ConstructRecordRow();
m_executionMetrics.RecordTotalTimerMeasurement();
return(underlyingRecordRowObject);
}
public override void PostFilterNextRow()
{
if (m_mustEvaluateThroughReportObjectModel)
{
m_currentRow = new Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow(m_odpContext.ReportObjectModel.FieldsImpl, m_dataSet.DataSetCore.Fields.Count, m_dataSetInstance.FieldInfos);
}
if (WritesDataChunk)
{
m_dataChunkWriter.WriteRecordRow(m_currentRow);
}
if (m_consumerRequest != null)
{
m_consumerRequest.NextRow(m_currentRow);
}
}
protected override void ProcessRow(Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow row, int rowNumber)
{
m_odpContext.ReportObjectModel.FieldsImpl.NewRow();
m_odpContext.ReportObjectModel.UpdateFieldValues(reuseFieldObjects: false, row, m_dataSetInstance, base.HasServerAggregateMetadata);
bool flag = true;
if (m_filters != null)
{
flag = m_filters.PassFilters(new DataFieldRow(m_odpContext.ReportObjectModel.FieldsImpl, getAndSave: false));
}
if (flag)
{
PostFilterNextRow();
}
}
private void PopulateServerAggregateInformationFromIndicatorFields(Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow recordRow)
{
int num = 0;
int num2 = 0;
for (int i = 0; i < recordRow.RecordFields.Length; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.RecordField recordField = recordRow.RecordFields[i];
Microsoft.ReportingServices.ReportIntermediateFormat.Field field = m_dataSet.Fields[i];
if (recordField == null || !field.HasAggregateIndicatorField)
{
continue;
}
num++;
Microsoft.ReportingServices.ReportIntermediateFormat.Field field2 = m_dataSet.Fields[field.AggregateIndicatorFieldIndex];
bool processedValue = false;
bool flag;
if (field2.IsCalculatedField)
{
if (field2.Value.Type == Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant)
{
processedValue = field2.Value.BoolValue;
flag = false;
}
else
{
flag = !Microsoft.ReportingServices.RdlExpressions.ReportRuntime.TryProcessObjectToBoolean(field2.Value.LiteralInfo.Value, out processedValue);
}
}
else
{
Microsoft.ReportingServices.ReportIntermediateFormat.RecordField recordField2 = recordRow.RecordFields[field.AggregateIndicatorFieldIndex];
flag = (recordField2 == null || recordField2.FieldStatus != 0 || !Microsoft.ReportingServices.RdlExpressions.ReportRuntime.TryProcessObjectToBoolean(recordField2.FieldValue, out processedValue));
}
if (flag)
{
m_odpContext.ErrorContext.Register(ProcessingErrorCode.rsMissingOrInvalidAggregateIndicatorFieldValue, Severity.Warning, Microsoft.ReportingServices.ReportProcessing.ObjectType.Field, field2.Name, "AggregateIndicatorField", m_dataSet.Name.MarkAsPrivate(), field.Name.MarkAsModelInfo());
}
else if (processedValue)
{
num2++;
recordRow.IsAggregateRow = true;
}
recordField.IsAggregationField = !processedValue;
}
recordRow.AggregationFieldCount = num - num2;
}
public void NextRow(Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow originalRow)
{
if (base.ProcessRetrievedData)
{
m_odpContext.CheckAndThrowIfAborted();
if (m_dataRowsRead == 0)
{
InitializeBeforeFirstRow(hasRows: true);
}
Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow recordRow = null;
recordRow = ((!m_iRowConsumerMappingIdentical) ? new Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow(originalRow, m_iRowConsumerMappingDataSetFieldIndexesToDataChunk) : originalRow);
if (m_dataSet.IsReferenceToSharedDataSet && recordRow.IsAggregateRow && m_dataSet.InterpretSubtotalsAsDetails != Microsoft.ReportingServices.ReportIntermediateFormat.DataSet.TriState.False)
{
recordRow.IsAggregateRow = false;
}
ProcessRow(recordRow, m_dataRowsRead);
IncrementRowCounterAndTrace();
}
}
public void NextRow(Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow row, int rowNumber, bool useRowOffset, bool readerExtensionsSupported)
{
FieldsImpl fieldsImplForUpdate = m_odpContext.ReportObjectModel.GetFieldsImplForUpdate(m_dataSet);
if (useRowOffset)
{
fieldsImplForUpdate.NewRow();
}
else
{
fieldsImplForUpdate.NewRow(row.StreamPosition);
}
if (fieldsImplForUpdate.AddRowIndex)
{
fieldsImplForUpdate.SetRowIndex(rowNumber);
}
m_odpContext.ReportObjectModel.UpdateFieldValues(reuseFieldObjects: false, row, m_dataSetInstance, readerExtensionsSupported);
m_dataSetObj.NextRow();
}
public bool ShouldSkip(OnDemandProcessingContext odpContext, Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow row)
{
if (row != null && m_enableRowSkipping)
{
foreach (RestartContext item in m_restartPosition)
{
switch (item.DoesNotMatchRowRecordField(odpContext, row.RecordFields))
{
case RowSkippingControlFlag.Skip:
if (item.RestartMode == RestartMode.Query)
{
item.TraceStartAtRecoveryMessage();
}
return(true);
case RowSkippingControlFlag.Stop:
return(false);
}
}
}
return(false);
}
internal RowInstance(FieldInfo[] fieldInfos, Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow recordRow)
{
m_recordRow = recordRow;
m_fieldInfos = fieldInfos;
}
protected abstract void ProcessRow(Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow aRow, int rowNumber);
internal void UpdateFieldValues(bool reuseFieldObjects, Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow row, DataSetInstance dataSetInstance, bool readerExtensionsSupported)
{
m_currentFields.UpdateFieldValues(this, UseDataSetFieldsCache, reuseFieldObjects, row, dataSetInstance, readerExtensionsSupported);
}
private Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow ConstructRecordRow()
{
Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow recordRow = new Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow();
bool flag = m_dataReader.ReaderExtensionsSupported && !m_dataSet.HasAggregateIndicatorFields;
bool flag2 = HasServerAggregateMetadata && (m_dataSet.InterpretSubtotalsAsDetails == Microsoft.ReportingServices.ReportIntermediateFormat.DataSet.TriState.False || (m_odpContext.IsSharedDataSetExecutionOnly && m_dataSet.InterpretSubtotalsAsDetails == Microsoft.ReportingServices.ReportIntermediateFormat.DataSet.TriState.Auto));
Microsoft.ReportingServices.ReportIntermediateFormat.RecordField[] array2 = recordRow.RecordFields = new Microsoft.ReportingServices.ReportIntermediateFormat.RecordField[m_dataSet.NonCalculatedFieldCount];
for (int i = 0; i < array2.Length; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.Field field = m_dataSet.Fields[i];
if (!m_dataSetInstance.IsFieldMissing(i))
{
Microsoft.ReportingServices.ReportIntermediateFormat.RecordField recordField = new Microsoft.ReportingServices.ReportIntermediateFormat.RecordField();
try
{
array2[i] = recordField;
recordField.FieldValue = m_dataReader.GetColumn(i);
if (flag2)
{
if (flag)
{
recordField.IsAggregationField = m_dataReader.IsAggregationField(i);
}
}
else
{
recordField.IsAggregationField = true;
}
recordField.FieldStatus = DataFieldStatus.None;
}
catch (ReportProcessingException_FieldError aException)
{
recordField = (array2[i] = HandleFieldError(aException, i, field.Name));
if (recordField != null && !flag2)
{
recordField.IsAggregationField = true;
}
}
ReadExtendedPropertiesForRecordField(i, field, recordField);
}
else
{
array2[i] = null;
}
}
if (flag2)
{
if (flag)
{
recordRow.IsAggregateRow = m_dataReader.IsAggregateRow;
recordRow.AggregationFieldCount = m_dataReader.AggregationFieldCount;
}
else
{
PopulateServerAggregateInformationFromIndicatorFields(recordRow);
}
}
else
{
recordRow.AggregationFieldCount = m_dataSet.Fields.Count;
}
return(recordRow);
}
internal void UpdateFieldValues(ObjectModelImpl reportOM, bool useDataSetFieldsCache, bool reuseFieldObjects, Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow row, DataSetInstance dataSetInstance, bool readerExtensionsSupported)
{
Global.Tracer.Assert(row != null, "Empty data row / no data reader");
if (m_dataSetInstance != dataSetInstance)
{
m_dataSetInstance = dataSetInstance;
m_dataSet = dataSetInstance.DataSetDef.DataSetCore;
if (m_dataSet.FieldsContext != null && useDataSetFieldsCache)
{
m_fields = m_dataSet.FieldsContext.Fields;
}
else
{
reuseFieldObjects = false;
}
m_dataReader = null;
m_lastRowOffset = DataFieldRow.UnInitializedStreamOffset;
m_pendingFieldValueUpdate = false;
}
m_allFieldsCleared = false;
FieldInfo[] fieldInfos = dataSetInstance.FieldInfos;
if (m_fields.ReaderExtensionsSupported && m_dataSet.InterpretSubtotalsAsDetails == Microsoft.ReportingServices.ReportIntermediateFormat.DataSet.TriState.False)
{
m_fields.IsAggregateRow = row.IsAggregateRow;
m_fields.AggregationFieldCount = row.AggregationFieldCount;
if (!row.IsAggregateRow)
{
m_fields.AggregationFieldCountForDetailRow = row.AggregationFieldCount;
}
}
int num = 0;
int count = m_dataSet.Fields.Count;
int num2 = row.RecordFields.Length;
for (num = 0; num < num2; num++)
{
FieldImpl fieldImpl = reuseFieldObjects ? m_fields.GetFieldByIndex(num) : null;
Microsoft.ReportingServices.ReportIntermediateFormat.Field fieldDef = m_dataSet.Fields[num];
Microsoft.ReportingServices.ReportIntermediateFormat.RecordField recordField = row.RecordFields[num];
if (recordField == null)
{
if (!reuseFieldObjects || fieldImpl == null)
{
fieldImpl = new FieldImpl(reportOM, DataFieldStatus.IsMissing, null, fieldDef);
}
else
{
fieldImpl.UpdateValue(null, isAggregationField: false, DataFieldStatus.IsMissing, null);
}
}
else if (recordField.FieldStatus == DataFieldStatus.None)
{
if (!reuseFieldObjects || fieldImpl == null)
{
fieldImpl = new FieldImpl(reportOM, recordField.FieldValue, recordField.IsAggregationField, fieldDef);
}
else
{
fieldImpl.UpdateValue(recordField.FieldValue, recordField.IsAggregationField, DataFieldStatus.None, null);
}
}
else if (!reuseFieldObjects || fieldImpl == null)
{
fieldImpl = new FieldImpl(reportOM, recordField.FieldStatus, ReportRuntime.GetErrorName(recordField.FieldStatus, null), fieldDef);
}
else
{
fieldImpl.UpdateValue(null, isAggregationField: false, recordField.FieldStatus, ReportRuntime.GetErrorName(recordField.FieldStatus, null));
}
if (recordField != null && fieldInfos != null)
{
FieldInfo fieldInfo = fieldInfos[num];
if (fieldInfo != null && fieldInfo.PropertyCount != 0 && recordField.FieldPropertyValues != null)
{
for (int i = 0; i < fieldInfo.PropertyCount; i++)
{
fieldImpl.SetProperty(fieldInfo.PropertyNames[i], recordField.FieldPropertyValues[i]);
}
}
}
m_fields[num] = fieldImpl;
}
if (num >= count)
{
return;
}
if (!reuseFieldObjects && reportOM.OdpContext.ReportRuntime.ReportExprHost != null)
{
m_dataSet.SetExprHost(reportOM.OdpContext.ReportRuntime.ReportExprHost, reportOM);
}
for (; num < count; num++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.Field fieldDef2 = m_dataSet.Fields[num];
FieldImpl fieldImpl2 = reuseFieldObjects ? m_fields.GetFieldByIndex(num) : null;
if (reuseFieldObjects && fieldImpl2 != null)
{
if (!fieldImpl2.ResetCalculatedField())
{
CreateAndInitializeCalculatedFieldWrapper(reportOM, readerExtensionsSupported, m_dataSet, num, fieldDef2);
}
}
else
{
CreateAndInitializeCalculatedFieldWrapper(reportOM, readerExtensionsSupported, m_dataSet, num, fieldDef2);
}
}
}
public void DisableRowSkipping(Microsoft.ReportingServices.ReportIntermediateFormat.RecordRow row)
{
m_enableRowSkipping = false;
}
