private async Task <bool> FillNextResultAsync(DataReaderContainer dataReader)
{
bool result = true;
if (_hasFillErrorHandler)
{
try
{
// only try-catch if a FillErrorEventHandler is registered so that
// in the default case we get the full callstack from users
result = await dataReader.NextResultAsync();
}
catch (Exception e)
{
//
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
ADP.TraceExceptionForCapture(e);
OnFillErrorHandler(e, null, null);
}
}
else
{
result = await dataReader.NextResultAsync();
}
return(result);
}
private async Task <int> FillLoadDataRowChunkAsync(SchemaMapping mapping, int startRecord, int maxRecords)
{
DataReaderContainer dataReader = mapping.DataReader;
while (0 < startRecord)
{
if (!await dataReader.ReadAsync())
{
// there are no more rows on first resultset
return(0);
}
--startRecord;
}
int rowsAddedToDataSet = 0;
if (0 < maxRecords)
{
while ((rowsAddedToDataSet < maxRecords) && await dataReader.ReadAsync())
{
if (_hasFillErrorHandler)
{
try
{
await mapping.LoadDataRowWithClear();
rowsAddedToDataSet++;
}
catch (Exception e)
{
//
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
ADP.TraceExceptionForCapture(e);
OnFillErrorHandler(e, mapping.DataTable, mapping.DataValues);
}
}
else
{
await mapping.LoadDataRow();
rowsAddedToDataSet++;
}
}
// skip remaining rows of the first resultset
}
else
{
rowsAddedToDataSet = await FillLoadDataRowAsync(mapping);
}
return(rowsAddedToDataSet);
}
internal async Task <object> FillSchemaFromReaderAsync(DataSet dataset, DataTable datatable, SchemaType schemaType, string srcTable, DbDataReader dataReader)
{
DataTable[] dataTables = null;
int schemaCount = 0;
do
{
DataReaderContainer readerHandler = DataReaderContainer.Create(dataReader, ReturnProviderSpecificTypes);
AssertReaderHandleFieldCount(readerHandler);
if (0 >= readerHandler.FieldCount)
{
continue;
}
string tmp = null;
if (null != dataset)
{
tmp = DataAdapter.GetSourceTableName(srcTable, schemaCount);
schemaCount++; // don't increment if no SchemaTable ( a non-row returning result )
}
SchemaMapping mapping = new SchemaMapping(this, dataset, datatable, readerHandler, true, schemaType, tmp, false, null, null);
if (null != datatable)
{
// do not read remaining results in single DataTable case
return(mapping.DataTable);
}
else if (null != mapping.DataTable)
{
if (null == dataTables)
{
dataTables = new DataTable[1] {
mapping.DataTable
};
}
else
{
dataTables = DataAdapter.AddDataTableToArray(dataTables, mapping.DataTable);
}
}
} while (await dataReader.NextResultAsync()); // FillSchema does not capture errors for FillError event
object value = dataTables;
if ((null == value) && (null == datatable))
{ // WebData 101757
value = new DataTable[0];
}
return(value); // null if datatable had no results
}
private async Task <int> FillLoadDataRowAsync(SchemaMapping mapping)
{
int rowsAddedToDataSet = 0;
DataReaderContainer dataReader = mapping.DataReader;
if (_hasFillErrorHandler)
{
while (await dataReader.ReadAsync())
{ // read remaining rows of first and subsequent resultsets
try
{
// only try-catch if a FillErrorEventHandler is registered so that
// in the default case we get the full callstack from users
await mapping.LoadDataRowWithClear();
rowsAddedToDataSet++;
}
catch (Exception e)
{
//
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
ADP.TraceExceptionForCapture(e);
OnFillErrorHandler(e, mapping.DataTable, mapping.DataValues);
}
}
}
else
{
while (await dataReader.ReadAsync())
{ // read remaining rows of first and subsequent resultset
await mapping.LoadDataRow();
rowsAddedToDataSet++;
}
}
return(rowsAddedToDataSet);
}
virtual protected async Task <int> FillAsync(DataSet dataSet, string srcTable, IDataReader dataReader, int startRecord, int maxRecords)
{ // V1.2.3300, DbDataAdapter V1.0.3300
IntPtr hscp;
Bid.ScopeEnter(out hscp, "<comm.DataAdapter.Fill|API> %d#, dataSet, srcTable, dataReader, startRecord, maxRecords\n", ObjectID);
try
{
if (null == dataSet)
{
throw ADP.FillRequires("dataSet");
}
if (ADP.IsEmpty(srcTable))
{
throw ADP.FillRequiresSourceTableName("srcTable");
}
if (null == dataReader)
{
throw ADP.FillRequires("dataReader");
}
if (startRecord < 0)
{
throw ADP.InvalidStartRecord("startRecord", startRecord);
}
if (maxRecords < 0)
{
throw ADP.InvalidMaxRecords("maxRecords", maxRecords);
}
if (dataReader.IsClosed)
{
return(0);
}
// user must Close/Dispose of the dataReader
DataReaderContainer readerHandler = DataReaderContainer.Create(dataReader, ReturnProviderSpecificTypes);
return(await FillFromReaderAsync(dataSet, null, srcTable, readerHandler, startRecord, maxRecords, null, null));
}
finally
{
Bid.ScopeLeave(ref hscp);
}
}
private SchemaMapping FillMapping(DataSet dataset, DataTable datatable, string srcTable, DataReaderContainer dataReader, int schemaCount, DataColumn parentChapterColumn, object parentChapterValue)
{
SchemaMapping mapping = null;
if (_hasFillErrorHandler)
{
try
{
// only try-catch if a FillErrorEventHandler is registered so that
// in the default case we get the full callstack from users
mapping = FillMappingInternal(dataset, datatable, srcTable, dataReader, schemaCount, parentChapterColumn, parentChapterValue);
}
catch (Exception e)
{
//
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
ADP.TraceExceptionForCapture(e);
OnFillErrorHandler(e, null, null);
}
}
else
{
mapping = FillMappingInternal(dataset, datatable, srcTable, dataReader, schemaCount, parentChapterColumn, parentChapterValue);
}
return(mapping);
}
private SchemaMapping FillMappingInternal(DataSet dataset, DataTable datatable, string srcTable, DataReaderContainer dataReader, int schemaCount, DataColumn parentChapterColumn, object parentChapterValue)
{
bool withKeyInfo = (MissingSchemaAction.AddWithKey == MissingSchemaAction);
string tmp = null;
if (null != dataset)
{
tmp = DataAdapter.GetSourceTableName(srcTable, schemaCount);
}
return(new SchemaMapping(this, dataset, datatable, dataReader, withKeyInfo, SchemaType.Mapped, tmp, true, parentChapterColumn, parentChapterValue));
}
internal async Task <int> FillFromReaderAsync(DataSet dataset, DataTable datatable, string srcTable, DataReaderContainer dataReader, int startRecord, int maxRecords, DataColumn parentChapterColumn, object parentChapterValue)
{
int rowsAddedToDataSet = 0;
int schemaCount = 0;
do
{
AssertReaderHandleFieldCount(dataReader);
if (0 >= dataReader.FieldCount)
{
continue; // loop to next result
}
SchemaMapping mapping = FillMapping(dataset, datatable, srcTable, dataReader, schemaCount, parentChapterColumn, parentChapterValue);
schemaCount++; // don't increment if no SchemaTable ( a non-row returning result )
AssertSchemaMapping(mapping);
if (null == mapping)
{
continue; // loop to next result
}
if (null == mapping.DataValues)
{
continue; // loop to next result
}
if (null == mapping.DataTable)
{
continue; // loop to next result
}
mapping.DataTable.BeginLoadData();
try
{
// startRecord and maxRecords only apply to the first resultset
if ((1 == schemaCount) && ((0 < startRecord) || (0 < maxRecords)))
{
rowsAddedToDataSet = await FillLoadDataRowChunkAsync(mapping, startRecord, maxRecords);
}
else
{
int count = await FillLoadDataRowAsync(mapping);
if (1 == schemaCount)
{ // MDAC 71347
// only return LoadDataRow count for first resultset
// not secondary or chaptered results
rowsAddedToDataSet = count;
}
}
}
finally
{
mapping.DataTable.EndLoadData();
}
if (null != datatable)
{
break; // do not read remaining results in single DataTable case
}
} while (await FillNextResultAsync(dataReader));
return(rowsAddedToDataSet);
}
virtual protected async Task <int> FillAsync(DataTable[] dataTables, IDataReader dataReader, int startRecord, int maxRecords)
{ // V1.2.3300
IntPtr hscp;
Bid.ScopeEnter(out hscp, "<comm.DataAdapter.Fill|API> %d#, dataTables[], dataReader, startRecord, maxRecords\n", ObjectID);
try
{
ADP.CheckArgumentLength(dataTables, "tables");
if ((null == dataTables) || (0 == dataTables.Length) || (null == dataTables[0]))
{
throw ADP.FillRequires("dataTable");
}
if (null == dataReader)
{
throw ADP.FillRequires("dataReader");
}
if ((1 < dataTables.Length) && ((0 != startRecord) || (0 != maxRecords)))
{
throw ADP.NotSupported(); // FillChildren is not supported with FillPage
}
int result = 0;
bool enforceContraints = false;
DataSet commonDataSet = dataTables[0].DataSet;
try
{
if (null != commonDataSet)
{
enforceContraints = commonDataSet.EnforceConstraints;
commonDataSet.EnforceConstraints = false;
}
for (int i = 0; i < dataTables.Length; ++i)
{
Debug.Assert(null != dataTables[i], "null DataTable Fill");
if (dataReader.IsClosed)
{
#if DEBUG
Debug.Assert(!_debugHookNonEmptySelectCommand, "Debug hook asserts data reader should be open");
#endif
break;
}
DataReaderContainer readerHandler = DataReaderContainer.Create(dataReader, ReturnProviderSpecificTypes);
AssertReaderHandleFieldCount(readerHandler);
if (readerHandler.FieldCount <= 0)
{
if (i == 0)
{
bool lastFillNextResult;
do
{
lastFillNextResult = await FillNextResultAsync(readerHandler);
}while (lastFillNextResult && readerHandler.FieldCount <= 0);
if (!lastFillNextResult)
{
break;
}
}
else
{
continue;
}
}
if ((0 < i) && !await FillNextResultAsync(readerHandler))
{
break;
}
// user must Close/Dispose of the dataReader
// user will have to call NextResult to access remaining results
int count = await FillFromReaderAsync(null, dataTables[i], null, readerHandler, startRecord, maxRecords, null, null);
if (0 == i)
{
result = count;
}
}
}
catch (ConstraintException)
{
enforceContraints = false;
throw;
}
finally
{
if (enforceContraints)
{
commonDataSet.EnforceConstraints = true;
}
}
return(result);
}
finally
{
Bid.ScopeLeave(ref hscp);
}
}
void AssertReaderHandleFieldCount(DataReaderContainer readerHandler)
{
#if DEBUG
Debug.Assert(!_debugHookNonEmptySelectCommand || readerHandler.FieldCount > 0, "Scenario expects non-empty results but no fields reported by reader");
#endif
}