internal OleDbHResult Commit()
{
Debug.Assert(_mustComplete, "transaction already completed");
OleDbHResult hr;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
DangerousAddRef(ref mustRelease);
RuntimeHelpers.PrepareConstrainedRegions();
try
{ }
finally
{
hr = (OleDbHResult)NativeOledbWrapper.ITransactionCommit(DangerousGetHandle());
if ((0 <= (int)hr) || (OleDbHResult.XACT_E_NOTRANSACTION == hr))
{
_mustComplete = false;
}
}
}
finally
{
if (mustRelease)
{
DangerousRelease();
}
}
return(hr);
}
internal OleDbHResult Commit()
{
OleDbHResult result;
bool success = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
base.DangerousAddRef(ref success);
Bid.Trace("<oledb.ITransactionLocal.Commit|API|OLEDB> handle=%p\n", base.handle);
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
result = NativeOledbWrapper.ITransactionCommit(base.DangerousGetHandle());
if ((OleDbHResult.S_OK <= result) || (OleDbHResult.XACT_E_NOTRANSACTION == result))
{
this._mustComplete = false;
}
}
Bid.Trace("<oledb.ITransactionLocal.Commit|API|OLEDB|RET> %08X{HRESULT}\n", result);
}
finally
{
if (success)
{
base.DangerousRelease();
}
}
return(result);
}
internal OleDbHResult Abort()
{
Debug.Assert(_mustComplete, "transaction already completed");
OleDbHResult hr;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
DangerousAddRef(ref mustRelease);
RuntimeHelpers.PrepareConstrainedRegions();
try
{ }
finally
{
hr = (OleDbHResult)NativeOledbWrapper.ITransactionAbort(DangerousGetHandle());
_mustComplete = false;
}
}
finally
{
if (mustRelease)
{
DangerousRelease();
}
}
return(hr);
}
internal void SetVariantValue(int offset, object value)
{
IntPtr ptrZero = ADP.PtrZero;
bool success = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
base.DangerousAddRef(ref success);
ptrZero = ADP.IntPtrOffset(base.DangerousGetHandle(), offset);
RuntimeHelpers.PrepareConstrainedRegions();
try
{
Marshal.GetNativeVariantForObject(value, ptrZero);
}
finally
{
NativeOledbWrapper.MemoryCopy(ADP.IntPtrOffset(ptrZero, ODB.SizeOf_Variant), ptrZero, ODB.SizeOf_Variant);
}
}
finally
{
if (success)
{
base.DangerousRelease();
}
}
}
private static unsafe void FreePropVariant(IntPtr buffer, int valueOffset)
{
// two contigous PROPVARIANT structures that need to be freed
// the second should only be freed if different from the first
Debug.Assert(0 == (sizeof(PROPVARIANT) % 8), "unexpected PROPVARIANT size mutiplier");
Debug.Assert(0 == valueOffset % 8, "unexpected unaligned ptr offset");
IntPtr currentHandle = ADP.IntPtrOffset(buffer, valueOffset);
IntPtr originalHandle = ADP.IntPtrOffset(buffer, valueOffset + sizeof(PROPVARIANT));
bool different = NativeOledbWrapper.MemoryCompare(currentHandle, originalHandle, sizeof(PROPVARIANT));
RuntimeHelpers.PrepareConstrainedRegions();
try
{ }
finally
{
// always clear the first structure
Interop.Ole32.PropVariantClear(currentHandle);
if (different)
{
// second structure different from the first
Interop.Ole32.PropVariantClear(originalHandle);
}
else
{
// second structure same as the first, just clear the field
SafeNativeMethods.ZeroMemory(originalHandle, sizeof(PROPVARIANT));
}
}
}
// translate to native
internal void SetVariantValue(int offset, object value)
{
// two contigous VARIANT structures, second should be a binary copy of the first
Debug.Assert(_needToReset, "data type requires reseting and _needToReset is false");
Debug.Assert(0 == (ODB.SizeOf_Variant % 8), "unexpected VARIANT size mutiplier");
Debug.Assert(0 == offset % 8, "invalid alignment");
ValidateCheck(offset, 2 * ODB.SizeOf_Variant);
IntPtr buffer = ADP.PtrZero;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
DangerousAddRef(ref mustRelease);
buffer = ADP.IntPtrOffset(DangerousGetHandle(), offset);
RuntimeHelpers.PrepareConstrainedRegions();
try {
// GetNativeVariantForObject must be in try block since it has no reliability contract
Marshal.GetNativeVariantForObject(value, buffer);
}
finally {
// safe to copy memory(dst,src,count), even if GetNativeVariantForObject failed
NativeOledbWrapper.MemoryCopy(ADP.IntPtrOffset(buffer, ODB.SizeOf_Variant), buffer, ODB.SizeOf_Variant);
}
}
finally {
if (mustRelease)
{
DangerousRelease();
}
}
}
internal OleDbHResult Commit()
{
Debug.Assert(_mustComplete, "transaction already completed");
OleDbHResult hr;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
DangerousAddRef(ref mustRelease);
Bid.Trace("<oledb.ITransactionLocal.Commit|API|OLEDB> handle=%p\n", base.handle);
RuntimeHelpers.PrepareConstrainedRegions();
try { } finally {
hr = (OleDbHResult)NativeOledbWrapper.ITransactionCommit(DangerousGetHandle());
if ((0 <= (int)hr) || (OleDbHResult.XACT_E_NOTRANSACTION == hr))
{
_mustComplete = false;
}
}
Bid.Trace("<oledb.ITransactionLocal.Commit|API|OLEDB|RET> %08X{HRESULT}\n", hr);
}
finally {
if (mustRelease)
{
DangerousRelease();
}
}
return(hr);
}
protected override bool ReleaseHandle()
{
if (_mustComplete && (IntPtr.Zero != base.handle))
{
NativeOledbWrapper.ITransactionAbort(base.handle);
_mustComplete = false;
}
return(base.ReleaseHandle());
}
protected override bool ReleaseHandle()
{
if (this._mustComplete && (IntPtr.Zero != base.handle))
{
Bid.Trace("<oledb.ITransactionLocal.Abort|API|OLEDB|INFO> handle=%p\n", base.handle);
OleDbHResult result = NativeOledbWrapper.ITransactionAbort(base.handle);
this._mustComplete = false;
Bid.Trace("<oledb.ITransactionLocal.Abort|API|OLEDB|INFO|RET> %08X{HRESULT}\n", result);
}
return(base.ReleaseHandle());
}
protected override bool ReleaseHandle()
{
// NOTE: The SafeHandle class guarantees this will be called exactly once and is non-interrutible.
IntPtr chapter = _chapterHandle;
_chapterHandle = IntPtr.Zero;
if ((IntPtr.Zero != base.handle) && (IntPtr.Zero != chapter))
{
OleDbHResult hr = (OleDbHResult)NativeOledbWrapper.IChapteredRowsetReleaseChapter(base.handle, chapter);
}
return(base.ReleaseHandle());
}
protected override bool ReleaseHandle()
{
IntPtr ptr = this._chapterHandle;
this._chapterHandle = IntPtr.Zero;
if ((IntPtr.Zero != base.handle) && (IntPtr.Zero != ptr))
{
Bid.Trace("<oledb.IChapteredRowset.ReleaseChapter|API|OLEDB> Chapter=%Id\n", ptr);
OleDbHResult result = NativeOledbWrapper.IChapteredRowsetReleaseChapter(base.handle, ptr);
Bid.Trace("<oledb.IChapteredRowset.ReleaseChapter|API|OLEDB|RET> %08X{HRESULT}\n", result);
}
return(base.ReleaseHandle());
}
protected override bool ReleaseHandle()
{
// NOTE: The SafeHandle class guarantees this will be called exactly once and is non-interrutible.
IntPtr chapter = _chapterHandle;
_chapterHandle = IntPtr.Zero;
if ((IntPtr.Zero != base.handle) && (IntPtr.Zero != chapter))
{
Bid.Trace("<oledb.IChapteredRowset.ReleaseChapter|API|OLEDB> Chapter=%Id\n", chapter);
OleDbHResult hr = (OleDbHResult)NativeOledbWrapper.IChapteredRowsetReleaseChapter(base.handle, chapter);
Bid.Trace("<oledb.IChapteredRowset.ReleaseChapter|API|OLEDB|RET> %08X{HRESULT}\n", hr);
}
return(base.ReleaseHandle());
}
private static void FreeVariant(IntPtr buffer, int valueOffset)
{
IntPtr ptr2 = ADP.IntPtrOffset(buffer, valueOffset);
IntPtr ptr = ADP.IntPtrOffset(buffer, valueOffset + ODB.SizeOf_Variant);
bool flag = NativeOledbWrapper.MemoryCompare(ptr2, ptr, ODB.SizeOf_Variant);
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
SafeNativeMethods.VariantClear(ptr2);
if (flag)
{
SafeNativeMethods.VariantClear(ptr);
}
else
{
SafeNativeMethods.ZeroMemory(ptr, (IntPtr)ODB.SizeOf_Variant);
}
}
}
