//protected override int Fill(DataTable dataTable, IDataReader dataReader) {
// return base.Fill(dataTable, dataReader);
//}
private int FillFromRecordset(object data, UnsafeNativeMethods.ADORecordsetConstruction recordset, string?srcTable, out bool incrementResultCount)
{
incrementResultCount = false;
IntPtr chapter; /*ODB.DB_NULL_HCHAPTER*/
object?result;
try
{
result = recordset.get_Rowset();
chapter = recordset.get_Chapter();
}
catch (Exception e)
{
// UNDONE - should not be catching all exceptions!!!
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
throw ODB.Fill_EmptyRecordSet("ADODBRecordSet", e);
}
if (null != result)
{
CommandBehavior behavior = (MissingSchemaAction.AddWithKey != MissingSchemaAction) ? 0 : CommandBehavior.KeyInfo;
behavior |= CommandBehavior.SequentialAccess;
OleDbDataReader?dataReader = null;
try
{
// initialized with chapter only since we don't want ReleaseChapter called for this chapter handle
ChapterHandle chapterHandle = ChapterHandle.CreateChapterHandle(chapter);
dataReader = new OleDbDataReader(null, null, 0, behavior);
dataReader.InitializeIRowset(result, chapterHandle, ADP.RecordsUnaffected);
dataReader.BuildMetaInfo();
incrementResultCount = (0 < dataReader.FieldCount);
if (incrementResultCount)
{
if (data is DataTable)
{
return(base.Fill((DataTable)data, dataReader));
}
else
{
return(base.Fill((DataSet)data, srcTable !, dataReader, 0, 0));
}
}
}
finally
{
dataReader?.Close();
}
}
return(0);
}
// returns true if there is an active data reader on the specified command
internal bool HasLiveReader(OleDbCommand cmd)
{
OleDbDataReader?reader = null;
if (null != ReferenceCollection)
{
reader = ReferenceCollection.FindItem <OleDbDataReader>(OleDbReferenceCollection.DataReaderTag, (dataReader) => cmd == dataReader.Command);
}
return(reader != null);
}
private int FillFromRecord(object data, UnsafeNativeMethods.ADORecordConstruction record, string srcTable)
{
object?result = null;
try
{
result = record.get_Row();
}
catch (Exception e)
{
// UNDONE - should not be catching all exceptions!!!
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
throw ODB.Fill_EmptyRecord("adodb", e);
}
if (null != result)
{
CommandBehavior behavior = (MissingSchemaAction.AddWithKey != MissingSchemaAction) ? 0 : CommandBehavior.KeyInfo;
behavior |= CommandBehavior.SequentialAccess | CommandBehavior.SingleRow;
OleDbDataReader?dataReader = null;
try
{
dataReader = new OleDbDataReader(null, null, 0, behavior);
dataReader.InitializeIRow(result, ADP.RecordsUnaffected);
dataReader.BuildMetaInfo();
if (data is DataTable)
{
return(base.Fill((DataTable)data, dataReader));
}
else
{
return(base.Fill((DataSet)data, srcTable, dataReader, 0, 0));
}
}
finally
{
if (null != dataReader)
{
dataReader.Close();
}
}
}
return(0);
}
internal ColumnBinding[] SetBindings(OleDbDataReader?dataReader, Bindings bindings,
int indexStart, int indexForAccessor,
OleDbParameter[]?parameters, tagDBBINDING[] dbbindings, bool ifIRowsetElseIRow)
{
Debug.Assert(null != bindings, "null bindings");
Debug.Assert(dbbindings.Length == BindingCount(), "count mismatch");
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
DangerousAddRef(ref mustRelease);
IntPtr buffer = DangerousGetHandle();
for (int i = 0; i < dbbindings.Length; ++i)
{
IntPtr ptr = ADP.IntPtrOffset(buffer, (i * ODB.SizeOf_tagDBBINDING));
Marshal.StructureToPtr(dbbindings[i], ptr, false /*deleteold*/);
}
}
finally
{
if (mustRelease)
{
DangerousRelease();
}
}
ColumnBinding[] columns = new ColumnBinding[dbbindings.Length];
for (int indexWithinAccessor = 0; indexWithinAccessor < columns.Length; ++indexWithinAccessor)
{
int index = indexStart + indexWithinAccessor;
OleDbParameter?parameter = parameters?[index];
columns[indexWithinAccessor] = new ColumnBinding(
dataReader !, index, indexForAccessor, indexWithinAccessor,
parameter, this, bindings, dbbindings[indexWithinAccessor], _headerLength,
ifIRowsetElseIRow);
}
return(columns);
}
private OleDbDataReader?ExecuteReaderInternal(CommandBehavior behavior, string method)
{
OleDbDataReader?dataReader = null;
OleDbException? nextResultsFailure = null;
int state = ODB.InternalStateClosed;
try
{
ValidateConnectionAndTransaction(method);
if (0 != (CommandBehavior.SingleRow & behavior))
{
// CommandBehavior.SingleRow implies CommandBehavior.SingleResult
behavior |= CommandBehavior.SingleResult;
}
object?executeResult;
int resultType;
switch (CommandType)
{
case 0: // uninitialized CommandType.Text
case CommandType.Text:
case CommandType.StoredProcedure:
resultType = ExecuteCommand(behavior, out executeResult);
break;
case CommandType.TableDirect:
resultType = ExecuteTableDirect(behavior, out executeResult);
break;
default:
throw ADP.InvalidCommandType(CommandType);
}
if (_executeQuery)
{
try
{
dataReader = new OleDbDataReader(_connection !, this, 0, this.commandBehavior);
switch (resultType)
{
case ODB.ExecutedIMultipleResults:
dataReader.InitializeIMultipleResults(executeResult);
dataReader.NextResult();
break;
case ODB.ExecutedIRowset:
dataReader.InitializeIRowset(executeResult, ChapterHandle.DB_NULL_HCHAPTER, _recordsAffected);
dataReader.BuildMetaInfo();
dataReader.HasRowsRead();
break;
case ODB.ExecutedIRow:
dataReader.InitializeIRow(executeResult, _recordsAffected);
dataReader.BuildMetaInfo();
break;
case ODB.PrepareICommandText:
if (!_isPrepared)
{
PrepareCommandText(2);
}
OleDbDataReader.GenerateSchemaTable(dataReader, _icommandText !, behavior);
break;
default:
Debug.Assert(false, "ExecuteReaderInternal: unknown result type");
break;
}
executeResult = null;
_hasDataReader = true;
_connection !.AddWeakReference(dataReader, OleDbReferenceCollection.DataReaderTag);
// command stays in the executing state until the connection
// has a datareader to track for it being closed
state = ODB.InternalStateOpen;
}
finally
{
if (ODB.InternalStateOpen != state)
{
this.canceling = true;
if (null != dataReader)
{
((IDisposable)dataReader).Dispose();
dataReader = null;
}
}
}
Debug.Assert(null != dataReader, "ExecuteReader should never return a null DataReader");
}
else
{ // optimized code path for ExecuteNonQuery to not create a OleDbDataReader object
try
{
if (ODB.ExecutedIMultipleResults == resultType)
{
UnsafeNativeMethods.IMultipleResults?multipleResults = (UnsafeNativeMethods.IMultipleResults?)executeResult;
// may cause a Connection.ResetState which closes connection
nextResultsFailure = OleDbDataReader.NextResults(multipleResults, _connection !, this, out _recordsAffected);
}
}
finally
{
try
{
if (null != executeResult)
{
Marshal.ReleaseComObject(executeResult);
executeResult = null;
}
CloseFromDataReader(ParameterBindings);
}
catch (Exception e)
{
// UNDONE - should not be catching all exceptions!!!
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
if (null != nextResultsFailure)
{
nextResultsFailure = new OleDbException(nextResultsFailure, e);
}
else
{
throw;
}
}
}
}
}
finally
{ // finally clear executing state
try
{
if ((null == dataReader) && (ODB.InternalStateOpen != state))
{
ParameterCleanup();
}
}
catch (Exception e)
{
// UNDONE - should not be catching all exceptions!!!
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
if (null != nextResultsFailure)
{
nextResultsFailure = new OleDbException(nextResultsFailure, e);
}
else
{
throw;
}
}
if (null != nextResultsFailure)
{
throw nextResultsFailure;
}
}
return(dataReader);
}
internal Bindings(OleDbDataReader dataReader, bool ifIRowsetElseIRow, int count) : this(count)
{
_dataReader = dataReader;
_ifIRowsetElseIRow = ifIRowsetElseIRow;
}