internal static Exception?ProcessResults(OleDbHResult hresult, OleDbConnection?connection, object?src)
{
if ((0 <= (int)hresult) && ((null == connection) || (null == connection.Events[EventInfoMessage])))
{
SafeNativeMethods.Wrapper.ClearErrorInfo();
return(null);
}
// ErrorInfo object is to be checked regardless the hresult returned by the function called
Exception? e = null;
OleDbHResult hr = UnsafeNativeMethods.GetErrorInfo(0, out UnsafeNativeMethods.IErrorInfo? errorInfo); // 0 - IErrorInfo exists, 1 - no IErrorInfo
if ((OleDbHResult.S_OK == hr) && (null != errorInfo))
{
try
{
if (hresult < 0)
{
// UNDONE: if authentication failed - throw a unique exception object type
//if (/*OLEDB_Error.DB_SEC_E_AUTH_FAILED*/unchecked((int)0x80040E4D) == hr) {
//}
//else if (/*OLEDB_Error.DB_E_CANCELED*/unchecked((int)0x80040E4E) == hr) {
//}
// else {
e = OleDbException.CreateException(errorInfo, hresult, null);
//}
if (OleDbHResult.DB_E_OBJECTOPEN == hresult)
{
e = ADP.OpenReaderExists(e);
}
ResetState(connection);
}
else
{
connection?.OnInfoMessage(errorInfo, hresult);
}
}
finally
{
UnsafeNativeMethods.ReleaseErrorInfoObject(errorInfo);
}
}
else if (0 < hresult)
{
// @devnote: OnInfoMessage with no ErrorInfo
}
else if ((int)hresult < 0)
{
e = ODB.NoErrorInformation(connection?.Provider, hresult, null); // OleDbException
ResetState(connection);
}
if (null != e)
{
ADP.TraceExceptionAsReturnValue(e);
}
return(e);
}
internal void OnInfoMessage(UnsafeNativeMethods.IErrorInfo errorInfo, OleDbHResult errorCode)
{
OleDbInfoMessageEventHandler handler = (OleDbInfoMessageEventHandler)Events[EventInfoMessage];
if (null != handler)
{
try
{
OleDbException exception = OleDbException.CreateException(errorInfo, errorCode, null);
OleDbInfoMessageEventArgs e = new OleDbInfoMessageEventArgs(exception);
handler(this, e);
}
catch (Exception e)
{ // eat the exception
// UNDONE - should not be catching all exceptions!!!
if (!ADP.IsCatchableOrSecurityExceptionType(e))
{
throw;
}
ADP.TraceExceptionWithoutRethrow(e);
}
}
#if DEBUG
else
{
OleDbException exception = OleDbException.CreateException(errorInfo, errorCode, null);
}
#endif
}
internal void OnInfoMessage(System.Data.Common.UnsafeNativeMethods.IErrorInfo errorInfo, OleDbHResult errorCode)
{
OleDbInfoMessageEventHandler handler = (OleDbInfoMessageEventHandler)base.Events[EventInfoMessage];
if (handler != null)
{
try
{
OleDbInfoMessageEventArgs e = new OleDbInfoMessageEventArgs(OleDbException.CreateException(errorInfo, errorCode, null));
if (Bid.TraceOn)
{
Bid.Trace("<oledb.OledbConnection.OnInfoMessage|API|INFO> %d#, Message='%ls'\n", this.ObjectID, e.Message);
}
handler(this, e);
}
catch (Exception exception)
{
if (!ADP.IsCatchableOrSecurityExceptionType(exception))
{
throw;
}
ADP.TraceExceptionWithoutRethrow(exception);
}
}
}
internal void OnInfoMessage(UnsafeNativeMethods.IErrorInfo errorInfo, OleDbHResult errorCode)
{
OleDbInfoMessageEventHandler handler = (OleDbInfoMessageEventHandler)Events[EventInfoMessage];
if (null != handler)
{
try {
OleDbException exception = OleDbException.CreateException(errorInfo, errorCode, null);
OleDbInfoMessageEventArgs e = new OleDbInfoMessageEventArgs(exception);
if (Bid.TraceOn)
{
Bid.Trace("<oledb.OledbConnection.OnInfoMessage|API|INFO> %d#, Message='%ls'\n", ObjectID, e.Message);
}
handler(this, e);
}
catch (Exception e) { // eat the exception
//
if (!ADP.IsCatchableOrSecurityExceptionType(e))
{
throw;
}
ADP.TraceExceptionWithoutRethrow(e);
}
}
#if DEBUG
else
{
OleDbException exception = OleDbException.CreateException(errorInfo, errorCode, null);
Bid.Trace("<oledb.OledbConnection.OnInfoMessage|API|INFO> %d#, Message='%ls'\n", ObjectID, exception.Message);
}
#endif
}
static internal Exception ProcessResults(OleDbHResult hresult, OleDbConnection connection, object src)
{
if ((0 <= (int)hresult) && ((null == connection) || (null == connection.Events[EventInfoMessage])))
{
SafeNativeMethods.Wrapper.ClearErrorInfo();
return(null);
}
// ErrorInfo object is to be checked regardless the hresult returned by the function called
Exception e = null;
UnsafeNativeMethods.IErrorInfo errorInfo = null;
OleDbHResult hr = UnsafeNativeMethods.GetErrorInfo(0, out errorInfo); // 0 - IErrorInfo exists, 1 - no IErrorInfo
if ((OleDbHResult.S_OK == hr) && (null != errorInfo))
{
if (hresult < 0)
{
//
e = OleDbException.CreateException(errorInfo, hresult, null);
//}
if (OleDbHResult.DB_E_OBJECTOPEN == hresult)
{
e = ADP.OpenReaderExists(e);
}
ResetState(connection);
}
else if (null != connection)
{
connection.OnInfoMessage(errorInfo, hresult);
}
else
{
Bid.Trace("<oledb.OledbConnection|WARN|INFO> ErrorInfo available, but not connection %08X{HRESULT}\n", hresult);
}
Marshal.ReleaseComObject(errorInfo);
}
else if (0 < hresult)
{
// @devnote: OnInfoMessage with no ErrorInfo
Bid.Trace("<oledb.OledbConnection|ERR|INFO> ErrorInfo not available %08X{HRESULT}\n", hresult);
}
else if ((int)hresult < 0)
{
e = ODB.NoErrorInformation((null != connection) ? connection.Provider : null, hresult, null); // OleDbException
ResetState(connection);
}
if (null != e)
{
ADP.TraceExceptionAsReturnValue(e);
}
return(e);
}
public static string DisplayOleDbErrorCollection(OleDbException exception)
{
string sError = "";
for (int i = 0; i < exception.Errors.Count; i++)
{
sError += "Index #" + i + "\n" +
"Message: " + exception.Errors[i].Message + "\n" +
"Native: " + exception.Errors[i].NativeError.ToString() + "\n" +
"Source: " + exception.Errors[i].Source + "\n" +
"SQL: " + exception.Errors[i].SQLState + "\n";
}
return sError;
}
internal static OleDbException NoErrorInformation(string provider, OleDbHResult hr, Exception inner)
{
OleDbException e;
if (!ADP.IsEmpty(provider))
{
e = new OleDbException(SR.Format(SR.OleDb_NoErrorInformation2, provider, ODB.ELookup(hr)), hr, inner);
}
else
{
e = new OleDbException(SR.Format(SR.OleDb_NoErrorInformation, ODB.ELookup(hr)), hr, inner);
}
ADP.TraceExceptionAsReturnValue(e);
return(e);
}
internal static OleDbException NoErrorInformation(string provider, OleDbHResult hr, Exception inner)
{
OleDbException exception;
if (!ADP.IsEmpty(provider))
{
exception = new OleDbException(Res.GetString("OleDb_NoErrorInformation2", new object[] { provider, ELookup(hr) }), hr, inner);
}
else
{
exception = new OleDbException(Res.GetString("OleDb_NoErrorInformation", new object[] { ELookup(hr) }), hr, inner);
}
ADP.TraceExceptionAsReturnValue(exception);
return(exception);
}
public String RegistrarExcepcion(Exception excepcion, String origen)
{
string mensaje = "";
try
{
if (excepcion is System.ApplicationException)
{
System.ApplicationException exc = (System.ApplicationException)excepcion;
mensaje = EscribirApplicationException(exc, origen);
}
else if (excepcion is System.IO.InvalidDataException)
{
System.IO.InvalidDataException exc = (System.IO.InvalidDataException)excepcion;
mensaje = EscribirInvalidDataException(exc, origen);
}
else if (excepcion is System.IO.IOException)
{
System.IO.IOException exc = (System.IO.IOException)excepcion;
mensaje = EscribirIOEx(exc, origen);
}
else if (excepcion is System.FormatException)
{
System.FormatException exc = excepcion as System.FormatException;
mensaje = EscribirFormatException(exc, origen);
}
else if (excepcion is System.Data.SqlClient.SqlException)
{
System.Data.SqlClient.SqlException exc = excepcion as System.Data.SqlClient.SqlException;
mensaje = EscribirSqlEx(exc, origen);
}
else if (excepcion is System.Data.OleDb.OleDbException)
{
System.Data.OleDb.OleDbException exc = excepcion as System.Data.OleDb.OleDbException;
mensaje = EscribirOleDbEx(exc, origen);
}
else
{
mensaje = EscribirGenericEx(excepcion, origen);
}
}
catch (Exception ex)
{
mensaje = "Error interno de la Aplicación. Por favor informar a Sopórte Técnico.\n\n";
mensaje = mensaje + EscribirLocalEx(ex, this.ToString() + ".RegistrarExcepcion");
}
return(mensaje);
}
internal static Exception ProcessResults(OleDbHResult hresult, OleDbConnection connection, object src)
{
if ((OleDbHResult.S_OK <= hresult) && ((connection == null) || (connection.Events[EventInfoMessage] == null)))
{
SafeNativeMethods.Wrapper.ClearErrorInfo();
return(null);
}
Exception e = null;
System.Data.Common.UnsafeNativeMethods.IErrorInfo ppIErrorInfo = null;
if ((System.Data.Common.UnsafeNativeMethods.GetErrorInfo(0, out ppIErrorInfo) == OleDbHResult.S_OK) && (ppIErrorInfo != null))
{
if (hresult < OleDbHResult.S_OK)
{
e = OleDbException.CreateException(ppIErrorInfo, hresult, null);
if (OleDbHResult.DB_E_OBJECTOPEN == hresult)
{
e = ADP.OpenReaderExists(e);
}
ResetState(connection);
}
else if (connection != null)
{
connection.OnInfoMessage(ppIErrorInfo, hresult);
}
else
{
Bid.Trace("<oledb.OledbConnection|WARN|INFO> ErrorInfo available, but not connection %08X{HRESULT}\n", hresult);
}
Marshal.ReleaseComObject(ppIErrorInfo);
}
else if (OleDbHResult.S_OK < hresult)
{
Bid.Trace("<oledb.OledbConnection|ERR|INFO> ErrorInfo not available %08X{HRESULT}\n", hresult);
}
else if (hresult < OleDbHResult.S_OK)
{
e = ODB.NoErrorInformation((connection != null) ? connection.Provider : null, hresult, null);
ResetState(connection);
}
if (e != null)
{
ADP.TraceExceptionAsReturnValue(e);
}
return(e);
}
public static void SQLErrorHandler(System.Data.OleDb.OleDbException E, Label Message)
{
try
{
Message.Style["font-size"] = "18pt";
Message.Style["color"] = MSG_ERROR_COLOR;
switch (E.ErrorCode)
{
case -2147217873:
Message.Text += MSG_SQL_ERROR_DUPLICATED_KEY;
break;
default:
Message.Text += MSG_SQL_ERROR_OTHER_PREFIX + "[" + E.ErrorCode.ToString() + "]" + E.ToString();
break;
}
}
catch (System.Exception e)
{
ErrorHandler(e, Message);
return;
}
}
internal static OleDbException NoErrorInformation(string provider, OleDbHResult hr, Exception inner)
{
OleDbException exception;
if (!ADP.IsEmpty(provider))
{
exception = new OleDbException(Res.GetString("OleDb_NoErrorInformation2", new object[] { provider, ELookup(hr) }), hr, inner);
}
else
{
exception = new OleDbException(Res.GetString("OleDb_NoErrorInformation", new object[] { ELookup(hr) }), hr, inner);
}
ADP.TraceExceptionAsReturnValue(exception);
return exception;
}
public List<IntelWebObject> Load(string whereclause, string sortorder, List<IntelWebField> filterparams)
{
if (!this.User.loggedIn) { return null; }
OleDbCommand tcommand;
if (commandType == System.Data.CommandType.StoredProcedure)
{
tcommand = new OleDbCommand(this.tableName, this.connection());
}
else
{
tcommand = new OleDbCommand(this.FullSelectStatement(whereclause, sortorder), this.connection());
}
tcommand.CommandType = commandType;
IntelWebParameter tempParam = new IntelWebParameter();
if (filterparams != null)
{
foreach (IntelWebField apfield in filterparams)
{
tcommand.Parameters.Add(apfield.parameter);
}
}
List<IntelWebObject> objcol = new List<IntelWebObject>();
try
{
OleDbDataReader oread = tcommand.ExecuteReader();
tcommand.Parameters.Clear();
while (oread.Read())
{
IntelWebObject myobj = (IntelWebObject)Activator.CreateInstance(this.GetType(), new object[] { this.User, this.selectFieldsList, false });
this.Construct(oread, myobj);
objcol.Add(myobj);
}
oread.Close();
}
catch (OleDbException ex)
{
_lastDBError = ex;
throw ex;
}
return objcol;
}
internal OleDbInfoMessageEventArgs(OleDbException exception)
{
Debug.Assert(null != exception, "OleDbInfoMessageEventArgs without OleDbException");
this.exception = exception;
}
public virtual bool save()
{
string tsql = "";
string sql2 = "";
string finalsql = "";
if (!this.isDirty)
{
return true;
}
if (this.primaryKey == null)
{
AddSaveError("The object has no primary key set.");
return false;
}
_saveerrors = validateRecord();
if (_saveerrors != null)
{
return false;
}
foreach (IntelWebField x in this.changedFields)
{
tsql += x.name;
if (!this.isNew)
{
tsql += " = ?";
}
else
{
sql2 += "?,";
}
tsql += ",";
}
if (this.isNew)
{
foreach (IntelWebField x in this.defaultFields)
{
if (!x.isAutoGenerated)
{
if (x.name.Equals("last_modified_by", StringComparison.InvariantCultureIgnoreCase))
{
x.fieldValue = this.User.userName;
}
tsql += x.name + ",";
sql2 += "?,";
}
}
}
if (sql2 != "") { sql2 = sql2.Substring(0, sql2.Length - 1); }
if (tsql != "") { tsql = tsql.Substring(0, tsql.Length - 1); }
if (this.isNew)
{
finalsql = "Insert into [" + this.tableName + "] (" + tsql + ") values (" + sql2 + ")";
}
else
{
finalsql = "Update [" + this.tableName + "] set " + tsql;
}
OleDbCommand tCommand = new OleDbCommand(finalsql, this.connection());
foreach (IntelWebField webfield in this.changedFields)
{
tCommand.Parameters.Add(webfield.parameter);
}
if (this.isNew)
{
foreach (IntelWebField webfield2 in this.defaultFields)
{
//Console.Write("'" + (webfield2.fieldValue != null ? webfield2.fieldValue.ToString() : "") + "',");
tCommand.Parameters.Add(webfield2.parameter);
}
}
else
{
finalsql += " where " + this.primaryKey.name + " = ?";
tCommand.Parameters.Add(this.primaryKey.parameter);
tCommand.CommandText = finalsql;
}
try
{
if (this.User.inTrans())
{
tCommand.Transaction = this.User.dbTrans();
}
int returnvalue = tCommand.ExecuteNonQuery();
tCommand.Parameters.Clear();
setPK(this);
this.afterSave();
this.isDirty = false;
this.isNew = false;
return true;
}
catch (OleDbException ex)
{
tCommand.Parameters.Clear();
_lastDBError = ex;
AddSaveError(ex.Message);
return false;
}
}
public ConnectionException(OleDbException ex, string connectionString)
: this((Exception)ex,
connectionString)
{
}
private OleDbDataReader ExecuteReaderInternal(CommandBehavior behavior, string method)
{
OleDbDataReader dataReader = null;
OleDbException previous = null;
int num2 = 0;
try
{
object obj2;
int num;
this.ValidateConnectionAndTransaction(method);
if ((CommandBehavior.SingleRow & behavior) != CommandBehavior.Default)
{
behavior |= CommandBehavior.SingleResult;
}
switch (this.CommandType)
{
case ((System.Data.CommandType) 0):
case System.Data.CommandType.Text:
case System.Data.CommandType.StoredProcedure:
num = this.ExecuteCommand(behavior, out obj2);
break;
case System.Data.CommandType.TableDirect:
num = this.ExecuteTableDirect(behavior, out obj2);
break;
default:
throw ADP.InvalidCommandType(this.CommandType);
}
if (this._executeQuery)
{
try
{
dataReader = new OleDbDataReader(this._connection, this, 0, this.commandBehavior);
switch (num)
{
case 0:
dataReader.InitializeIMultipleResults(obj2);
dataReader.NextResult();
break;
case 1:
dataReader.InitializeIRowset(obj2, ChapterHandle.DB_NULL_HCHAPTER, this._recordsAffected);
dataReader.BuildMetaInfo();
dataReader.HasRowsRead();
break;
case 2:
dataReader.InitializeIRow(obj2, this._recordsAffected);
dataReader.BuildMetaInfo();
break;
case 3:
if (!this._isPrepared)
{
this.PrepareCommandText(2);
}
OleDbDataReader.GenerateSchemaTable(dataReader, this._icommandText, behavior);
break;
}
obj2 = null;
this._hasDataReader = true;
this._connection.AddWeakReference(dataReader, 2);
num2 = 1;
return(dataReader);
}
finally
{
if (1 != num2)
{
this.canceling = true;
if (dataReader != null)
{
dataReader.Dispose();
dataReader = null;
}
}
}
}
try
{
if (num == 0)
{
UnsafeNativeMethods.IMultipleResults imultipleResults = (UnsafeNativeMethods.IMultipleResults)obj2;
previous = OleDbDataReader.NextResults(imultipleResults, this._connection, this, out this._recordsAffected);
}
}
finally
{
try
{
if (obj2 != null)
{
Marshal.ReleaseComObject(obj2);
obj2 = null;
}
this.CloseFromDataReader(this.ParameterBindings);
}
catch (Exception exception3)
{
if (!ADP.IsCatchableExceptionType(exception3))
{
throw;
}
if (previous == null)
{
throw;
}
previous = new OleDbException(previous, exception3);
}
}
}
finally
{
try
{
if ((dataReader == null) && (1 != num2))
{
this.ParameterCleanup();
}
}
catch (Exception exception2)
{
if (!ADP.IsCatchableExceptionType(exception2))
{
throw;
}
if (previous == null)
{
throw;
}
previous = new OleDbException(previous, exception2);
}
if (previous != null)
{
throw previous;
}
}
return(dataReader);
}
public static tgConcurrencyException CheckForConcurrencyException(OleDbException ex)
{
tgConcurrencyException ce = null;
if (ex.Errors != null)
{
foreach (OleDbError err in ex.Errors)
{
if (err.NativeError == 532)
{
ce = new tgConcurrencyException(err.Message, ex);
ce.Source = err.Source;
break;
}
}
}
return ce;
}
internal OleDbInfoMessageEventArgs(OleDbException exception) {
Debug.Assert(null != exception, "OleDbInfoMessageEventArgs without OleDbException");
this.exception = exception;
}
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; // MDAC 72655
}
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) {
//
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)) { // MDAC 67218
ParameterCleanup();
}
}
catch(Exception e) {
//
if (!ADP.IsCatchableExceptionType(e)) {
throw;
}
if (null != nextResultsFailure) {
nextResultsFailure = new OleDbException(nextResultsFailure, e);
}
else {
throw;
}
}
if (null != nextResultsFailure) {
throw nextResultsFailure;
}
}
return dataReader;
}
private void HandleOleDbException(OleDbException xcp)
{
Logger.Log(xcp);
if (xcp.Message.StartsWith("Unrecognized database format"))
{
throw new OleDbDatabaseFormatException(
string.Format("Database connection string: {0}", ConnectionString), xcp);
}
else if (xcp.Message.StartsWith("The Microsoft Jet database engine cannot find the input table or query"))
{
throw new OleDbMissingTableException(
string.Format("Missing table name: {0}", TableName), xcp);
}
else
{
throw new Exception("Non specific OleDbException.", xcp);
}
}
private OleDbDataReader ExecuteReaderInternal(CommandBehavior behavior, string method)
{
OleDbDataReader dataReader = null;
OleDbException previous = null;
int num2 = 0;
try
{
object obj2;
int num;
this.ValidateConnectionAndTransaction(method);
if ((CommandBehavior.SingleRow & behavior) != CommandBehavior.Default)
{
behavior |= CommandBehavior.SingleResult;
}
switch (this.CommandType)
{
case ((System.Data.CommandType) 0):
case System.Data.CommandType.Text:
case System.Data.CommandType.StoredProcedure:
num = this.ExecuteCommand(behavior, out obj2);
break;
case System.Data.CommandType.TableDirect:
num = this.ExecuteTableDirect(behavior, out obj2);
break;
default:
throw ADP.InvalidCommandType(this.CommandType);
}
if (this._executeQuery)
{
try
{
dataReader = new OleDbDataReader(this._connection, this, 0, this.commandBehavior);
switch (num)
{
case 0:
dataReader.InitializeIMultipleResults(obj2);
dataReader.NextResult();
break;
case 1:
dataReader.InitializeIRowset(obj2, ChapterHandle.DB_NULL_HCHAPTER, this._recordsAffected);
dataReader.BuildMetaInfo();
dataReader.HasRowsRead();
break;
case 2:
dataReader.InitializeIRow(obj2, this._recordsAffected);
dataReader.BuildMetaInfo();
break;
case 3:
if (!this._isPrepared)
{
this.PrepareCommandText(2);
}
OleDbDataReader.GenerateSchemaTable(dataReader, this._icommandText, behavior);
break;
}
obj2 = null;
this._hasDataReader = true;
this._connection.AddWeakReference(dataReader, 2);
num2 = 1;
return dataReader;
}
finally
{
if (1 != num2)
{
this.canceling = true;
if (dataReader != null)
{
dataReader.Dispose();
dataReader = null;
}
}
}
}
try
{
if (num == 0)
{
UnsafeNativeMethods.IMultipleResults imultipleResults = (UnsafeNativeMethods.IMultipleResults) obj2;
previous = OleDbDataReader.NextResults(imultipleResults, this._connection, this, out this._recordsAffected);
}
}
finally
{
try
{
if (obj2 != null)
{
Marshal.ReleaseComObject(obj2);
obj2 = null;
}
this.CloseFromDataReader(this.ParameterBindings);
}
catch (Exception exception3)
{
if (!ADP.IsCatchableExceptionType(exception3))
{
throw;
}
if (previous == null)
{
throw;
}
previous = new OleDbException(previous, exception3);
}
}
}
finally
{
try
{
if ((dataReader == null) && (1 != num2))
{
this.ParameterCleanup();
}
}
catch (Exception exception2)
{
if (!ADP.IsCatchableExceptionType(exception2))
{
throw;
}
if (previous == null)
{
throw;
}
previous = new OleDbException(previous, exception2);
}
if (previous != null)
{
throw previous;
}
}
return dataReader;
}
static internal OleDbException NoErrorInformation(string provider, OleDbHResult hr, Exception inner) {
OleDbException e;
if (!ADP.IsEmpty(provider)) {
e = new OleDbException(Res.GetString(Res.OleDb_NoErrorInformation2, provider, ODB.ELookup(hr)), hr, inner);
}
else {
e = new OleDbException(Res.GetString(Res.OleDb_NoErrorInformation, ODB.ELookup(hr)), hr, inner);
}
ADP.TraceExceptionAsReturnValue(e);
return e;
}
protected void DisplayOleDbErrorCollection(OleDbException exception)
{
for (int i = 0; i < exception.Errors.Count; i++)
{
Console.WriteLine("Index #" + i + "\n" +
"Message: " + exception.Errors[i].Message + "\n" +
"Native: " + exception.Errors[i].NativeError.ToString() + "\n" +
"Source: " + exception.Errors[i].Source + "\n" +
"SQL: " + exception.Errors[i].SQLState + "\n");
}
Console.ReadLine();
}
public Error()
{
ex = (OleDbException)(base.InnerException);
}
internal OleDbException(OleDbException previous, Exception inner) : base(previous.Message, inner)
{
base.HResult = previous.ErrorCode;
this.oledbErrors = previous.oledbErrors;
}
public Error(string message)
{
ex = (OleDbException)(base.InnerException);
}
internal OleDbInfoMessageEventArgs(OleDbException exception)
{
this.exception = exception;
}
public Error(string message, System.Exception inner)
{
ex = (OleDbException)(base.InnerException);
}
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);
}
protected Error(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
{
ex = (OleDbException)(base.InnerException);
}
internal OleDbException(OleDbException previous, Exception inner) : base(previous.Message, inner)
{
HResult = previous.ErrorCode;
this.oledbErrors = previous.oledbErrors;
}
internal OleDbInfoMessageEventArgs(OleDbException exception)
{
this.exception = exception;
}
