// IDBSchemaRowset.GetSchemas internal DualCoTaskMem(UnsafeNativeMethods.IDBSchemaRowset dbSchemaRowset, out int schemaCount, out IntPtr schemaGuids, out IntPtr schemaRestrictions, out OleDbHResult hr) : this() { Bid.Trace("<oledb.IDBSchemaRowset.GetSchemas|API|OLEDB>\n"); hr = dbSchemaRowset.GetSchemas(out schemaCount, out base.handle, out this.handle2); schemaGuids = base.handle; schemaRestrictions = this.handle2; Bid.Trace("<oledb.IDBSchemaRowset.GetSchemas|API|OLEDB|RET> %08X{HRESULT}\n", hr); }
internal DualCoTaskMem(UnsafeNativeMethods.IColumnsInfo columnsInfo, out IntPtr columnCount, out IntPtr columnInfos, out OleDbHResult hr) : this() { Bid.Trace("<oledb.IColumnsInfo.GetColumnInfo|API|OLEDB>\n"); hr = columnsInfo.GetColumnInfo(out columnCount, out this.handle, out this.handle2); columnInfos = base.handle; Bid.Trace("<oledb.IColumnsInfo.GetColumnInfo|API|OLEDB|RET> %08X{HRESULT}\n", hr); }
// IDBInfo.GetLiteralInfo internal DualCoTaskMem(UnsafeNativeMethods.IDBInfo dbInfo, int[] literals, out int literalCount, out IntPtr literalInfo, out OleDbHResult hr) : this() { int count = (null != literals) ? literals.Length : 0; Bid.Trace("<oledb.IDBInfo.GetLiteralInfo|API|OLEDB>\n"); hr = dbInfo.GetLiteralInfo(count, literals, out literalCount, out base.handle, out this.handle2); literalInfo = base.handle; Bid.Trace("<oledb.IDBInfo.GetLiteralInfo|API|OLEDB|RET> %08X{HRESULT}\n", hr); }
internal WrappedTransaction(UnsafeNativeMethods.ITransactionLocal transaction, int isolevel, out OleDbHResult hr) : base(transaction) { int transactionLevel = 0; Bid.Trace("<oledb.ITransactionLocal.StartTransaction|API|OLEDB>\n"); RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { hr = transaction.StartTransaction(isolevel, 0, IntPtr.Zero, out transactionLevel); if (0 <= hr) { _mustComplete = true; } } Bid.Trace("<oledb.ITransactionLocal.StartTransaction|API|OLEDB|RET> %08X{HRESULT}\n", hr); }
internal DBPropSet(UnsafeNativeMethods.IRowsetInfo properties, PropertyIDSet propidset, out OleDbHResult hr) : this() { int cPropertyIDSets = 0; if (propidset != null) { cPropertyIDSets = propidset.Count; } Bid.Trace("<oledb.IRowsetInfo.GetProperties|API|OLEDB>\n"); hr = properties.GetProperties(cPropertyIDSets, propidset, out this.propertySetCount, out this.handle); Bid.Trace("<oledb.IRowsetInfo.GetProperties|API|OLEDB|RET> %08X{HRESULT}\n", hr); if (hr < OleDbHResult.S_OK) { this.SetLastErrorInfo(hr); } }
internal DBPropSet(UnsafeNativeMethods.ICommandProperties properties, PropertyIDSet propidset, out OleDbHResult hr) : this() { Debug.Assert(null != properties, "null ICommandProperties"); int propidsetcount = 0; if (null != propidset) { propidsetcount = propidset.Count; } Bid.Trace("<oledb.ICommandProperties.GetProperties|API|OLEDB>\n"); hr = properties.GetProperties(propidsetcount, propidset, out this.propertySetCount, out base.handle); Bid.Trace("<oledb.ICommandProperties.GetProperties|API|OLEDB|RET> %08X{HRESULT}\n", hr); if (hr < 0) { // VSDD 621427: remember the last HRESULT. Note we do not want to raise exception now to avoid breaking change from Orcas RTM/SP1 SetLastErrorInfo(hr); } }
internal static OleDbException CreateException(System.Data.Common.UnsafeNativeMethods.IErrorInfo errorInfo, OleDbHResult errorCode, Exception inner) { OleDbErrorCollection errors = new OleDbErrorCollection(errorInfo); string pBstrDescription = null; string pBstrSource = null; OleDbHResult description = OleDbHResult.S_OK; if (errorInfo != null) { description = errorInfo.GetDescription(out pBstrDescription); Bid.Trace("<oledb.IErrorInfo.GetDescription|API|OS|RET> %08X{HRESULT}, Description='%ls'\n", description, pBstrDescription); description = errorInfo.GetSource(out pBstrSource); Bid.Trace("<oledb.IErrorInfo.GetSource|API|OS|RET> %08X{HRESULT}, Source='%ls'\n", description, pBstrSource); } int count = errors.Count; if (0 < errors.Count) { StringBuilder builder = new StringBuilder(); if ((pBstrDescription != null) && (pBstrDescription != errors[0].Message)) { builder.Append(pBstrDescription.TrimEnd(ODB.ErrorTrimCharacters)); if (1 < count) { builder.Append(Environment.NewLine); } } for (int i = 0; i < count; i++) { if (0 < i) { builder.Append(Environment.NewLine); } builder.Append(errors[i].Message.TrimEnd(ODB.ErrorTrimCharacters)); } pBstrDescription = builder.ToString(); } if (ADP.IsEmpty(pBstrDescription)) { pBstrDescription = ODB.NoErrorMessage(errorCode); } return new OleDbException(pBstrDescription, inner, pBstrSource, errorCode, errors); }
static internal OleDbException CreateException(UnsafeNativeMethods.IErrorInfo errorInfo, OleDbHResult errorCode, Exception inner) { // MDAC 84364 OleDbErrorCollection errors = new OleDbErrorCollection(errorInfo); string message = null; string source = null; OleDbHResult hr = 0; if (null != errorInfo) { hr = errorInfo.GetDescription(out message); Bid.Trace("<oledb.IErrorInfo.GetDescription|API|OS|RET> %08X{HRESULT}, Description='%ls'\n", hr, message); hr = errorInfo.GetSource(out source); Bid.Trace("<oledb.IErrorInfo.GetSource|API|OS|RET> %08X{HRESULT}, Source='%ls'\n", hr, source); } int count = errors.Count; if (0 < errors.Count) { StringBuilder builder = new StringBuilder(); if ((null != message) && (message != errors[0].Message)) { // WebData 103032 builder.Append(message.TrimEnd(ODB.ErrorTrimCharacters)); // MDAC 73707 if (1 < count) { builder.Append(Environment.NewLine); } } for (int i = 0; i < count; ++i) { if (0 < i) { builder.Append(Environment.NewLine); } builder.Append(errors[i].Message.TrimEnd(ODB.ErrorTrimCharacters)); // MDAC 73707 } message = builder.ToString(); } if (ADP.IsEmpty(message)) { message = ODB.NoErrorMessage(errorCode); // MDAC 71170 } return new OleDbException(message, inner, source, errorCode, errors); }
/*protected virtual*/ internal OleDbHResult RollbackInternal(bool exceptionHandling) { OleDbHResult hr = 0; if (null != _transaction) { if (null != _nestedTransaction) { OleDbTransaction?transaction = (OleDbTransaction?)_nestedTransaction.Target; if ((null != transaction) && _nestedTransaction.IsAlive) { hr = transaction.RollbackInternal(exceptionHandling); if (exceptionHandling && (hr < 0)) { SafeNativeMethods.Wrapper.ClearErrorInfo(); return(hr); } } _nestedTransaction = null; } hr = _transaction.Abort(); _transaction.Dispose(); _transaction = null; if (hr < 0) { if (exceptionHandling) { ProcessResults(hr); } else { SafeNativeMethods.Wrapper.ClearErrorInfo(); } } } return(hr); }
private void FillClose(bool isrecordset, object value) { OleDbHResult hr; if (isrecordset) { hr = ((UnsafeNativeMethods.Recordset15)value).Close(); } else { hr = ((UnsafeNativeMethods._ADORecord)value).Close(); } if ((0 < (int)hr) && (ODB.ADODB_AlreadyClosedError != (int)hr)) { UnsafeNativeMethods.IErrorInfo errorInfo = null; UnsafeNativeMethods.GetErrorInfo(0, out errorInfo); string message = String.Empty; if (null != errorInfo) { OleDbHResult hresult = ODB.GetErrorDescription(errorInfo, hr, out message); } throw new COMException(message, (int)hr); } }
private static OleDbDataReader GetEnumeratorReader(object value) { System.Data.Common.NativeMethods.ISourcesRowset rowset = null; try { rowset = (System.Data.Common.NativeMethods.ISourcesRowset)value; } catch (InvalidCastException) { throw ODB.ISourcesRowsetNotSupported(); } if (rowset == null) { throw ODB.ISourcesRowsetNotSupported(); } value = null; int cPropertySets = 0; IntPtr ptrZero = ADP.PtrZero; Bid.Trace("<oledb.ISourcesRowset.GetSourcesRowset|API|OLEDB> IID_IRowset\n"); OleDbHResult result = rowset.GetSourcesRowset(ADP.PtrZero, ODB.IID_IRowset, cPropertySets, ptrZero, out value); Bid.Trace("<oledb.ISourcesRowset.GetSourcesRowset|API|OLEDB|RET> %08X{HRESULT}\n", result); Exception exception = OleDbConnection.ProcessResults(result, null, null); if (exception != null) { throw exception; } OleDbDataReader reader = new OleDbDataReader(null, null, 0, CommandBehavior.Default); reader.InitializeIRowset(value, ChapterHandle.DB_NULL_HCHAPTER, ADP.RecordsUnaffected); reader.BuildMetaInfo(); reader.HasRowsRead(); return(reader); }
private void PrepareCommandText(int expectedExecutionCount) { OleDbParameterCollection parameters = this._parameters; if (parameters != null) { foreach (OleDbParameter parameter in parameters) { if (parameter.IsParameterComputed()) { parameter.Prepare(this); } } } System.Data.Common.UnsafeNativeMethods.ICommandPrepare prepare = this.ICommandPrepare(); if (prepare != null) { Bid.Trace("<oledb.ICommandPrepare.Prepare|API|OLEDB> %d#, expectedExecutionCount=%d\n", this.ObjectID, expectedExecutionCount); OleDbHResult result = prepare.Prepare(expectedExecutionCount); Bid.Trace("<oledb.ICommandPrepare.Prepare|API|OLEDB|RET> %08X{HRESULT}\n", result); this.ProcessResults(result); } this._isPrepared = true; }
private void CreateAccessor() { System.Data.Common.UnsafeNativeMethods.ICommandWithParameters commandWithParameters = this.ICommandWithParameters(); OleDbParameterCollection parameters = this._parameters; OleDbParameter[] array = new OleDbParameter[parameters.Count]; parameters.CopyTo(array, 0); Bindings bindings = new Bindings(array, parameters.ChangeID); for (int i = 0; i < array.Length; i++) { bindings.ForceRebind |= array[i].BindParameter(i, bindings); } bindings.AllocateForAccessor(null, 0, 0); this.ApplyParameterBindings(commandWithParameters, bindings.BindInfo); System.Data.Common.UnsafeNativeMethods.IAccessor iaccessor = this.IAccessor(); OleDbHResult hr = bindings.CreateAccessor(iaccessor, 4); if (hr < OleDbHResult.S_OK) { this.ProcessResults(hr); } this._dbBindings = bindings; }
internal OleDbHResult CreateCommand(ref object icommandText) { OleDbHResult result = OleDbHResult.E_NOINTERFACE; UnsafeNativeMethods.IDBCreateCommandCreateCommand dangerousIDBCreateCommandCreateCommand = this.DangerousIDBCreateCommandCreateCommand; if (dangerousIDBCreateCommandCreateCommand != null) { bool success = false; RuntimeHelpers.PrepareConstrainedRegions(); try { base.DangerousAddRef(ref success); result = dangerousIDBCreateCommandCreateCommand(base.handle, IntPtr.Zero, ref ODB.IID_ICommandText, ref icommandText); } finally { if (success) { base.DangerousRelease(); } } } return(result); }
private static OleDbDataReader GetEnumeratorReader(object value) { NativeMethods.ISourcesRowset srcrowset = null; try { srcrowset = (NativeMethods.ISourcesRowset)value; } catch (InvalidCastException) { throw ODB.ISourcesRowsetNotSupported(); } if (null == srcrowset) { throw ODB.ISourcesRowsetNotSupported(); } value = null; // still held by ISourcesRowset, reused for IRowset int propCount = 0; IntPtr propSets = ADP.PtrZero; OleDbHResult hr = srcrowset.GetSourcesRowset(ADP.PtrZero, ODB.IID_IRowset, propCount, propSets, out value); Exception f = OleDbConnection.ProcessResults(hr, null, null); if (null != f) { throw f; } OleDbDataReader dataReader = new OleDbDataReader(null, null, 0, CommandBehavior.Default); dataReader.InitializeIRowset(value, ChapterHandle.DB_NULL_HCHAPTER, ADP.RecordsUnaffected); dataReader.BuildMetaInfo(); dataReader.HasRowsRead(); return(dataReader); }
internal OleDbHResult RollbackInternal(bool exceptionHandling) { OleDbHResult hr = OleDbHResult.S_OK; if (this._transaction != null) { if (this._nestedTransaction != null) { OleDbTransaction target = (OleDbTransaction)this._nestedTransaction.Target; if ((target != null) && this._nestedTransaction.IsAlive) { hr = target.RollbackInternal(exceptionHandling); if (exceptionHandling && (hr < OleDbHResult.S_OK)) { SafeNativeMethods.Wrapper.ClearErrorInfo(); return(hr); } } this._nestedTransaction = null; } hr = this._transaction.Abort(); this._transaction.Dispose(); this._transaction = null; if (hr >= OleDbHResult.S_OK) { return(hr); } if (exceptionHandling) { this.ProcessResults(hr); return(hr); } SafeNativeMethods.Wrapper.ClearErrorInfo(); } return(hr); }
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); } } }
private void SetLastErrorInfo(OleDbHResult lastErrorHr) { // note: OleDbHResult is actually a simple wrapper over HRESULT with OLEDB-specific codes UnsafeNativeMethods.IErrorInfo errorInfo = null; string message = String.Empty; OleDbHResult errorInfoHr = UnsafeNativeMethods.GetErrorInfo(0, out errorInfo); // 0 - IErrorInfo exists, 1 - no IErrorInfo if ((errorInfoHr == OleDbHResult.S_OK) && (errorInfo != null)) { ODB.GetErrorDescription(errorInfo, lastErrorHr, out message); // note that either GetErrorInfo or GetErrorDescription might fail in which case we will have only the HRESULT value in exception message } lastErrorFromProvider = new COMException(message, (int)lastErrorHr); }
// IDBInfo.GetLiteralInfo internal DualCoTaskMem(UnsafeNativeMethods.IDBInfo dbInfo, int[] literals, out int literalCount, out IntPtr literalInfo, out OleDbHResult hr) : this() { int count = (null != literals) ? literals.Length : 0; hr = dbInfo.GetLiteralInfo(count, literals, out literalCount, out base.handle, out this.handle2); literalInfo = base.handle; }
internal DualCoTaskMem(UnsafeNativeMethods.IColumnsInfo columnsInfo, out IntPtr columnCount, out IntPtr columnInfos, out OleDbHResult hr) : this() { Bid.Trace("<oledb.IColumnsInfo.GetColumnInfo|API|OLEDB>\n"); hr = columnsInfo.GetColumnInfo(out columnCount, out this.handle, out this.handle2); columnInfos = base.handle; Bid.Trace("<oledb.IColumnsInfo.GetColumnInfo|API|OLEDB|RET> %08X{HRESULT}\n", hr); }
static internal OleDbHResult GetErrorDescription(UnsafeNativeMethods.IErrorInfo errorInfo, OleDbHResult hresult, out string message) { Bid.Trace("<oledb.IErrorInfo.GetDescription|API|OS>\n"); OleDbHResult hr = errorInfo.GetDescription(out message); Bid.Trace("<oledb.IErrorInfo.GetDescription|API|OS|RET> %08X{HRESULT}, Message='%ls'\n", hr, message); if (((int)hr < 0) && ADP.IsEmpty(message)) { message = FailedGetDescription(hr) + Environment.NewLine + ODB.ELookup(hresult); } if (ADP.IsEmpty(message)) { message = ODB.ELookup(hresult); } return hr; }
internal OleDbException(string message, OleDbHResult errorCode, Exception inner) : base(message, inner) { HResult = (int)errorCode; this.oledbErrors = new OleDbErrorCollection(null); }
private void ProcessResultsNoReset(OleDbHResult hr) { Exception exception = OleDbConnection.ProcessResults(hr, null, this); if (exception != null) { throw exception; } }
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; }
internal static string FailedGetDescription(OleDbHResult errorcode) { return(SR.Format(SR.OleDb_FailedGetDescription, ODB.ELookup(errorcode))); }
private int FillFromADODB(Object data, object adodb, string srcTable, bool multipleResults) { Debug.Assert(null != data, "FillFromADODB: null data object"); Debug.Assert(null != adodb, "FillFromADODB: null ADODB"); Debug.Assert(!(adodb is DataTable), "call Fill( (DataTable) value)"); Debug.Assert(!(adodb is DataSet), "call Fill( (DataSet) value)"); /* * IntPtr adodbptr = ADP.PtrZero; * try { // generate a new COM Callable Wrapper around the user object so they can't ReleaseComObject on us. * adodbptr = Marshal.GetIUnknownForObject(adodb); * adodb = System.Runtime.Remoting.Services.EnterpriseServicesHelper.WrapIUnknownWithComObject(adodbptr); * } * finally { * if (ADP.PtrZero != adodbptr) { * Marshal.Release(adodbptr); * } * } */ bool closeRecordset = multipleResults; // MDAC 60332, 66668 Bid.Trace("<oledb.IUnknown.QueryInterface|API|OLEDB|ADODB> ADORecordsetConstruction\n"); UnsafeNativeMethods.ADORecordsetConstruction recordset = (adodb as UnsafeNativeMethods.ADORecordsetConstruction); UnsafeNativeMethods.ADORecordConstruction record = null; if (null != recordset) // MDAC 78415 { if (multipleResults) { // The NextRecordset method is not available on a disconnected Recordset object, where ActiveConnection has been set to NULL object activeConnection; Bid.Trace("<oledb.Recordset15.get_ActiveConnection|API|ADODB>\n"); activeConnection = ((UnsafeNativeMethods.Recordset15)adodb).get_ActiveConnection(); if (null == activeConnection) { multipleResults = false; } } } else { Bid.Trace("<oledb.IUnknown.QueryInterface|API|OLEDB|ADODB> ADORecordConstruction\n"); record = (adodb as UnsafeNativeMethods.ADORecordConstruction); if (null != record) // MDAC 78415 { multipleResults = false; // IRow implies CommandBehavior.SingleRow which implies CommandBehavior.SingleResult } } // else throw ODB.Fill_NotADODB("adodb"); /* throw later, less code here*/ int results = 0; if (null != recordset) { int resultCount = 0; bool incrementResultCount; // MDAC 59632 object[] value = new object[1]; do { string tmp = null; if (data is DataSet) { tmp = GetSourceTableName(srcTable, resultCount); } results += FillFromRecordset(data, recordset, tmp, out incrementResultCount); if (multipleResults) { value[0] = DBNull.Value; object recordsAffected; object nextresult; Bid.Trace("<oledb.Recordset15.NextRecordset|API|ADODB>\n"); OleDbHResult hr = ((UnsafeNativeMethods.Recordset15)adodb).NextRecordset(out recordsAffected, out nextresult); // MDAC 78415 Bid.Trace("<oledb.Recordset15.NextRecordset|API|ADODB|RET> %08X{HRESULT}\n", hr); if (0 > hr) { // Current provider does not support returning multiple recordsets from a single execution. if (ODB.ADODB_NextResultError != (int)hr) { UnsafeNativeMethods.IErrorInfo errorInfo = null; UnsafeNativeMethods.GetErrorInfo(0, out errorInfo); string message = String.Empty; if (null != errorInfo) { OleDbHResult hresult = ODB.GetErrorDescription(errorInfo, hr, out message); } throw new COMException(message, (int)hr); } break; } adodb = nextresult; if (null != adodb) { Bid.Trace("<oledb.IUnknown.QueryInterface|API|OLEDB|ADODB> ADORecordsetConstruction\n"); recordset = (UnsafeNativeMethods.ADORecordsetConstruction)adodb; if (incrementResultCount) { resultCount++; } continue; } } break; } while(null != recordset); if ((null != recordset) && (closeRecordset || (null == adodb))) // MDAC 59746, 60902 { FillClose(true, recordset); } } else if (null != record) { results = FillFromRecord(data, record, srcTable); if (closeRecordset) // MDAC 66668 { FillClose(false, record); // MDAC 60848 } } else { throw ODB.Fill_NotADODB("adodb"); } return(results); }
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); } } }
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; }
private OleDbException(string message, Exception inner, string source, OleDbHResult errorCode, OleDbErrorCollection errors) : base(message, inner) { // MDAC 84364 Debug.Assert(null != errors, "OleDbException without OleDbErrorCollection"); Source = source; HResult = (int)errorCode; this.oledbErrors = errors; }
// Debug error string writeline static internal string ELookup(OleDbHResult hr) { StringBuilder builder = new StringBuilder(); builder.Append(hr.ToString()); if ((0 < builder.Length) && Char.IsDigit(builder[0])) { builder.Length = 0; } builder.Append("(0x"); builder.Append(((int)hr).ToString("X8", CultureInfo.InvariantCulture)); builder.Append(")"); return builder.ToString(); }
// IDBSchemaRowset.GetSchemas internal DualCoTaskMem(UnsafeNativeMethods.IDBSchemaRowset dbSchemaRowset, out int schemaCount, out IntPtr schemaGuids, out IntPtr schemaRestrictions, out OleDbHResult hr) : this() { hr = dbSchemaRowset.GetSchemas(out schemaCount, out base.handle, out this.handle2); schemaGuids = base.handle; schemaRestrictions = this.handle2; }
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 }
internal DBPropSet(UnsafeNativeMethods.ICommandProperties properties, PropertyIDSet propidset, out OleDbHResult hr) : this() { Debug.Assert(null != properties, "null ICommandProperties"); int propidsetcount = 0; if (null != propidset) { propidsetcount = propidset.Count; } hr = properties.GetProperties(propidsetcount, propidset, out this.propertySetCount, out base.handle); if (hr < 0) { // remember the last HRESULT. Note we do not want to raise exception now to avoid breaking change from Orcas RTM/SP1 SetLastErrorInfo(hr); } }
internal DualCoTaskMem(UnsafeNativeMethods.IColumnsRowset icolumnsRowset, out IntPtr cOptColumns, out OleDbHResult hr) : base(IntPtr.Zero, true) { Bid.Trace("<oledb.IColumnsRowset.GetAvailableColumns|API|OLEDB>\n"); hr = icolumnsRowset.GetAvailableColumns(out cOptColumns, out base.handle); Bid.Trace("<oledb.IColumnsRowset.GetAvailableColumns|API|OLEDB|RET> %08X{HRESULT}\n", hr); }
internal static OleDbHResult GetErrorDescription(UnsafeNativeMethods.IErrorInfo errorInfo, OleDbHResult hresult, out string message) { OleDbHResult hr = errorInfo.GetDescription(out message); if (((int)hr < 0) && ADP.IsEmpty(message)) { message = FailedGetDescription(hr) + Environment.NewLine + ODB.ELookup(hresult); } if (ADP.IsEmpty(message)) { message = ODB.ELookup(hresult); } return(hr); }
private void ProcessResults(OleDbHResult hr) { Exception e; if (null != _command) { e = OleDbConnection.ProcessResults(hr, _connection, _command); } else { e = OleDbConnection.ProcessResults(hr, _connection, _connection); } if (null != e) { throw e; } }
static internal string FailedGetDescription(OleDbHResult errorcode) { return Res.GetString(Res.OleDb_FailedGetDescription, ODB.ELookup(errorcode)); }
internal DualCoTaskMem(UnsafeNativeMethods.IDBSchemaRowset dbSchemaRowset, out int schemaCount, out IntPtr schemaGuids, out IntPtr schemaRestrictions, out OleDbHResult hr) : this() { Bid.Trace("<oledb.IDBSchemaRowset.GetSchemas|API|OLEDB>\n"); hr = dbSchemaRowset.GetSchemas(out schemaCount, out this.handle, out this.handle2); schemaGuids = base.handle; schemaRestrictions = this.handle2; Bid.Trace("<oledb.IDBSchemaRowset.GetSchemas|API|OLEDB|RET> %08X{HRESULT}\n", hr); }
internal DualCoTaskMem(UnsafeNativeMethods.IColumnsRowset icolumnsRowset, out IntPtr cOptColumns, out OleDbHResult hr) : base(IntPtr.Zero, true) { Bid.Trace("<oledb.IColumnsRowset.GetAvailableColumns|API|OLEDB>\n"); hr = icolumnsRowset.GetAvailableColumns(out cOptColumns, out this.handle); Bid.Trace("<oledb.IColumnsRowset.GetAvailableColumns|API|OLEDB|RET> %08X{HRESULT}\n", hr); }
internal WrappedTransaction(UnsafeNativeMethods.ITransactionLocal transaction, int isolevel, out OleDbHResult hr) : base(transaction) { int transactionLevel = 0; RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { hr = transaction.StartTransaction(isolevel, 0, IntPtr.Zero, out transactionLevel); if (0 <= hr) { _mustComplete = true; } } }
internal DualCoTaskMem(UnsafeNativeMethods.IDBInfo dbInfo, int[] literals, out int literalCount, out IntPtr literalInfo, out OleDbHResult hr) : this() { int cLiterals = (literals != null) ? literals.Length : 0; Bid.Trace("<oledb.IDBInfo.GetLiteralInfo|API|OLEDB>\n"); hr = dbInfo.GetLiteralInfo(cLiterals, literals, out literalCount, out this.handle, out this.handle2); literalInfo = base.handle; Bid.Trace("<oledb.IDBInfo.GetLiteralInfo|API|OLEDB|RET> %08X{HRESULT}\n", hr); }
static internal string FailedGetSource(OleDbHResult errorcode) { return Res.GetString(Res.OleDb_FailedGetSource, ODB.ELookup(errorcode)); }
internal WrappedTransaction(UnsafeNativeMethods.ITransactionLocal transaction, int isolevel, out OleDbHResult hr) : base(transaction) { int pulTransactionLevel = 0; Bid.Trace("<oledb.ITransactionLocal.StartTransaction|API|OLEDB>\n"); RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { hr = transaction.StartTransaction(isolevel, 0, IntPtr.Zero, out pulTransactionLevel); if (OleDbHResult.S_OK <= hr) { this._mustComplete = true; } } Bid.Trace("<oledb.ITransactionLocal.StartTransaction|API|OLEDB|RET> %08X{HRESULT}\n", hr); }
private void ProcessResults(OleDbHResult hr) { Exception exception; if (this._command != null) { exception = OleDbConnection.ProcessResults(hr, this._connection, this._command); } else { exception = OleDbConnection.ProcessResults(hr, this._connection, this._connection); } if (exception != null) { throw exception; } }
private Exception ExecuteCommandTextSpecialErrorHandling(OleDbHResult hr, Exception e) { if (((OleDbHResult.DB_E_ERRORSOCCURRED == hr) || (OleDbHResult.DB_E_BADBINDINFO == hr)) && (this._dbBindings != null)) { StringBuilder builder = new StringBuilder(); this.ParameterBindings.ParameterStatus(builder); e = ODB.CommandParameterStatus(builder.ToString(), e); } return e; }
private void ProcessResultsNoReset(OleDbHResult hr) { Exception e = OleDbConnection.ProcessResults(hr, null, this); if (null != e) { throw e; } }
internal OleDbConnectionInternal(OleDbConnectionString constr, OleDbConnection connection) : base() { Debug.Assert((null != constr) && !constr.IsEmpty, "empty connectionstring"); ConnectionString = constr; if (constr.PossiblePrompt && !System.Environment.UserInteractive) { throw ODB.PossiblePromptNotUserInteractive(); } try { // this is the native DataLinks object which pools the native datasource/session OleDbServicesWrapper wrapper = OleDbConnectionInternal.GetObjectPool(); _datasrcwrp = new DataSourceWrapper(); // DataLinks wrapper will call IDataInitialize::GetDataSource to create the DataSource // uses constr.ActualConnectionString, no InfoMessageEvent checking wrapper.GetDataSource(constr, ref _datasrcwrp); Debug.Assert(!_datasrcwrp.IsInvalid, "bad DataSource"); // initialization is delayed because of OleDbConnectionStringBuilder only wants // pre-Initialize IDBPropertyInfo & IDBProperties on the data source if (null != connection) { _sessionwrp = new SessionWrapper(); // From the DataSource object, will call IDBInitialize.Initialize & IDBCreateSession.CreateSession // We always need both called so we use a single call for a single DangerousAddRef/DangerousRelease pair. OleDbHResult hr = _datasrcwrp.InitializeAndCreateSession(constr, ref _sessionwrp); // process the HResult here instead of from the SafeHandle because the possibility // of an InfoMessageEvent. if ((0 <= hr) && !_sessionwrp.IsInvalid) { // process infonessage events OleDbConnection.ProcessResults(hr, connection, connection); } else { Exception e = OleDbConnection.ProcessResults(hr, null, null); Debug.Assert(null != e, "CreateSessionError"); throw e; } Debug.Assert(!_sessionwrp.IsInvalid, "bad Session"); } } catch { if (null != _sessionwrp) { _sessionwrp.Dispose(); _sessionwrp = null; } if (null != _datasrcwrp) { _datasrcwrp.Dispose(); _datasrcwrp = null; } throw; } }
private void ExecuteCommandTextErrorHandling(OleDbHResult hr) { Exception e = OleDbConnection.ProcessResults(hr, _connection, this); if (null != e) { e = ExecuteCommandTextSpecialErrorHandling(hr, e); throw e; } }
// IColumnsInfo.GetColumnInfo internal DualCoTaskMem(UnsafeNativeMethods.IColumnsInfo columnsInfo, out IntPtr columnCount, out IntPtr columnInfos, out OleDbHResult hr) : this() { hr = columnsInfo.GetColumnInfo(out columnCount, out base.handle, out this.handle2); columnInfos = base.handle; }
private Exception ExecuteCommandTextSpecialErrorHandling(OleDbHResult hr, Exception e) { if (((OleDbHResult.DB_E_ERRORSOCCURRED == hr) || (OleDbHResult.DB_E_BADBINDINFO == hr)) && (null != _dbBindings)) { // MDAC 66026, 67039 // // this code exist to try for a better user error message by post-morten detection // of invalid parameter types being passed to a provider that doesn't understand // the user specified parameter OleDbType Debug.Assert(null != e, "missing inner exception"); StringBuilder builder = new StringBuilder(); ParameterBindings.ParameterStatus(builder); e = ODB.CommandParameterStatus(builder.ToString(), e); } return e; }
internal DualCoTaskMem(UnsafeNativeMethods.IColumnsRowset icolumnsRowset, out IntPtr cOptColumns, out OleDbHResult hr) : base(IntPtr.Zero, true) { hr = icolumnsRowset.GetAvailableColumns(out cOptColumns, out base.handle); }
internal OleDbException(string message, OleDbHResult errorCode, Exception inner) : base(message, inner) { base.HResult = (int) errorCode; this.oledbErrors = new OleDbErrorCollection(null); }
internal static string NoErrorMessage(OleDbHResult errorcode) { return(SR.Format(SR.OleDb_NoErrorMessage, ODB.ELookup(errorcode))); }
private OleDbException(string message, Exception inner, string source, OleDbHResult errorCode, OleDbErrorCollection errors) : base(message, inner) { this.Source = source; base.HResult = (int) errorCode; this.oledbErrors = errors; }
internal static string FailedGetSource(OleDbHResult errorcode) { return(SR.Format(SR.OleDb_FailedGetSource, ODB.ELookup(errorcode))); }
private void ProcessResults(OleDbHResult hr) { OleDbConnection connection = Connection; // get value from weakref only once Exception e = OleDbConnection.ProcessResults(hr, connection, connection); if (null != e) { throw e; } }
private int FillFromADODB(object data, object adodb, string?srcTable, bool multipleResults) { Debug.Assert(null != data, "FillFromADODB: null data object"); Debug.Assert(null != adodb, "FillFromADODB: null ADODB"); Debug.Assert(!(adodb is DataTable), "call Fill( (DataTable) value)"); Debug.Assert(!(adodb is DataSet), "call Fill( (DataSet) value)"); /* * IntPtr adodbptr = ADP.PtrZero; * try { // generate a new COM Callable Wrapper around the user object so they can't ReleaseComObject on us. * adodbptr = Marshal.GetIUnknownForObject(adodb); * adodb = System.Runtime.Remoting.Services.EnterpriseServicesHelper.WrapIUnknownWithComObject(adodbptr); * } * finally { * if (ADP.PtrZero != adodbptr) { * Marshal.Release(adodbptr); * } * } */ bool closeRecordset = multipleResults; UnsafeNativeMethods.ADORecordsetConstruction?recordset = (adodb as UnsafeNativeMethods.ADORecordsetConstruction); UnsafeNativeMethods.ADORecordConstruction? record = null; if (null != recordset) { if (multipleResults) { // The NextRecordset method is not available on a disconnected Recordset object, where ActiveConnection has been set to NULL object activeConnection; activeConnection = ((UnsafeNativeMethods.Recordset15)adodb).get_ActiveConnection(); if (null == activeConnection) { multipleResults = false; } } } else { record = (adodb as UnsafeNativeMethods.ADORecordConstruction); if (null != record) { multipleResults = false; // IRow implies CommandBehavior.SingleRow which implies CommandBehavior.SingleResult } } // else throw ODB.Fill_NotADODB("adodb"); /* throw later, less code here*/ int results = 0; if (null != recordset) { int resultCount = 0; bool incrementResultCount; object[] value = new object[1]; do { string?tmp = null; if (data is DataSet) { tmp = GetSourceTableName(srcTable !, resultCount); } results += FillFromRecordset(data, recordset, tmp, out incrementResultCount); if (multipleResults) { value[0] = DBNull.Value; object recordsAffected; object nextresult; OleDbHResult hr = ((UnsafeNativeMethods.Recordset15)adodb).NextRecordset(out recordsAffected, out nextresult); if (0 > hr) { // Current provider does not support returning multiple recordsets from a single execution. if (ODB.ADODB_NextResultError != (int)hr) { SafeNativeMethods.Wrapper.ClearErrorInfo(); string message = string.Empty; throw new COMException(message, (int)hr); } break; } adodb = nextresult; if (null != adodb) { recordset = (UnsafeNativeMethods.ADORecordsetConstruction)adodb; if (incrementResultCount) { resultCount++; } continue; } } break; } while (null != recordset); if ((null != recordset) && (closeRecordset || (null == adodb))) { FillClose(true, recordset); } } else if (null != record) { results = FillFromRecord(data, record, srcTable !); if (closeRecordset) { FillClose(false, record); } } else { throw ODB.Fill_NotADODB("adodb"); } return(results); }
private void ProcessResults(OleDbHResult hr) { Exception e = OleDbConnection.ProcessResults(hr, _parentConnection, this); if (null != e) { throw e; } }
static internal OleDbException CreateException(UnsafeNativeMethods.IErrorInfo errorInfo, OleDbHResult errorCode, Exception inner) { OleDbErrorCollection errors = new OleDbErrorCollection(errorInfo); string message = null; string source = null; OleDbHResult hr = 0; if (null != errorInfo) { hr = errorInfo.GetDescription(out message); hr = errorInfo.GetSource(out source); } int count = errors.Count; if (0 < errors.Count) { StringBuilder builder = new StringBuilder(); if ((null != message) && (message != errors[0].Message)) { builder.Append(message.TrimEnd(ODB.ErrorTrimCharacters)); if (1 < count) { builder.Append(Environment.NewLine); } } for (int i = 0; i < count; ++i) { if (0 < i) { builder.Append(Environment.NewLine); } builder.Append(errors[i].Message.TrimEnd(ODB.ErrorTrimCharacters)); } message = builder.ToString(); } if (ADP.IsEmpty(message)) { message = ODB.NoErrorMessage(errorCode); } return(new OleDbException(message, inner, source, errorCode, errors)); }
static internal string NoErrorMessage(OleDbHResult errorcode) { return Res.GetString(Res.OleDb_NoErrorMessage, ODB.ELookup(errorcode)); }