|
//------------------------------------------------------------------------------
// <copyright file="ColumnBinding.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="false">Microsoft</owner>
//------------------------------------------------------------------------------
namespace System.Data.OleDb {
using System;
using System.Diagnostics;
using System.Data;
using System.Data.Common;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
sealed internal class ColumnBinding {
// shared with other ColumnBindings
private readonly OleDbDataReader _dataReader; // HCHAPTER
private readonly RowBinding _rowbinding; // for native buffer interaction
private readonly Bindings _bindings;
// unique to this ColumnBinding
private readonly OleDbParameter _parameter; // output value
private readonly int _parameterChangeID;
private readonly int _offsetStatus;
private readonly int _offsetLength;
private readonly int _offsetValue;
private readonly int _ordinal;
private readonly int _maxLen;
private readonly short _wType;
private readonly byte _precision;
private readonly int _index;
private readonly int _indexForAccessor; // HCHAPTER
private readonly int _indexWithinAccessor; // HCHAPTER
private readonly bool _ifIRowsetElseIRow;
// unique per current input value
private int _valueBindingOffset;
private int _valueBindingSize;
internal StringMemHandle _sptr;
private GCHandle _pinnedBuffer;
// value is cached via property getters so the original may be released
// for Value, ValueByteArray, ValueString, ValueVariant
private object _value;
internal ColumnBinding(OleDbDataReader dataReader, int index, int indexForAccessor, int indexWithinAccessor,
OleDbParameter parameter, RowBinding rowbinding, Bindings bindings, tagDBBINDING binding, int offset,
bool ifIRowsetElseIRow) {
Debug.Assert(null != rowbinding, "null rowbinding");
Debug.Assert(null != bindings, "null bindings");
Debug.Assert(ODB.SizeOf_tagDBBINDING <= offset, "invalid offset" + offset);
_dataReader = dataReader;
_rowbinding = rowbinding;
_bindings = bindings;
_index = index;
_indexForAccessor = indexForAccessor;
_indexWithinAccessor = indexWithinAccessor;
if (null != parameter) {
_parameter = parameter;
_parameterChangeID = parameter.ChangeID;
}
_offsetStatus = binding.obStatus.ToInt32() + offset;
_offsetLength = binding.obLength.ToInt32() + offset;
_offsetValue = binding.obValue.ToInt32() + offset;
Debug.Assert(0 <= _offsetStatus, "negative _offsetStatus");
Debug.Assert(0 <= _offsetLength, "negative _offsetLength");
Debug.Assert(0 <= _offsetValue, "negative _offsetValue");
_ordinal = binding.iOrdinal.ToInt32();
_maxLen = binding.cbMaxLen.ToInt32();
_wType = binding.wType;
_precision = binding.bPrecision;
_ifIRowsetElseIRow = ifIRowsetElseIRow;
SetSize(Bindings.ParamSize.ToInt32());
}
internal Bindings Bindings {
get {
_bindings.CurrentIndex = IndexWithinAccessor;
return _bindings;
}
}
internal RowBinding RowBinding {
get { return _rowbinding; }
}
internal int ColumnBindingOrdinal {
get { return _ordinal; }
}
private int ColumnBindingMaxLen {
get { return _maxLen; }
}
private byte ColumnBindingPrecision {
get { return _precision; }
}
private short DbType {
get { return _wType; }
}
private Type ExpectedType {
get { return NativeDBType.FromDBType(DbType, false, false).dataType; }
}
internal int Index {
get { return _index; }
}
internal int IndexForAccessor {
get { return _indexForAccessor; }
}
internal int IndexWithinAccessor {
get { return _indexWithinAccessor; }
}
private int ValueBindingOffset { // offset within the value of where to start copying
get { return _valueBindingOffset; }
}
private int ValueBindingSize { // maximum size of the value to copy
get { return _valueBindingSize; }
}
internal int ValueOffset { // offset within the native buffer to put the value
get { return _offsetValue; }
}
private OleDbDataReader DataReader() {
Debug.Assert(null != _dataReader, "null DataReader");
return _dataReader;
}
internal bool IsParameterBindingInvalid(OleDbParameter parameter) {
Debug.Assert((null != _parameter) && (null != parameter), "null parameter");
return ((_parameter.ChangeID != _parameterChangeID) || (_parameter != parameter));
}
internal bool IsValueNull() {
return ((DBStatus.S_ISNULL == StatusValue())
|| (((NativeDBType.VARIANT == DbType) || (NativeDBType.PROPVARIANT == DbType))
&& (Convert.IsDBNull(ValueVariant()))));
}
private int LengthValue() {
int length;
if (_ifIRowsetElseIRow) {
length = RowBinding.ReadIntPtr(_offsetLength).ToInt32();
}
else { // WebData 94427
length = Bindings.DBColumnAccess[IndexWithinAccessor].cbDataLen.ToInt32();
}
return Math.Max(length, 0);
}
private void LengthValue(int value) {
Debug.Assert(0 <= value, "negative LengthValue");
RowBinding.WriteIntPtr(_offsetLength, (IntPtr)value);
}
internal OleDbParameter Parameter() {
Debug.Assert(null != _parameter, "null parameter");
return _parameter;
}
internal void ResetValue() {
_value = null;
StringMemHandle sptr = _sptr;
_sptr = null;
if (null != sptr) {
sptr.Dispose();
}
if (_pinnedBuffer.IsAllocated) {
_pinnedBuffer.Free();
}
}
internal DBStatus StatusValue() {
if (_ifIRowsetElseIRow) {
return (DBStatus) RowBinding.ReadInt32(_offsetStatus);
}
else { // WebData 94427
return (DBStatus) Bindings.DBColumnAccess[IndexWithinAccessor].dwStatus;
}
}
internal void StatusValue(DBStatus value) {
#if DEBUG
switch(value) {
case DBStatus.S_OK:
case DBStatus.S_ISNULL:
case DBStatus.S_DEFAULT:
break;
default:
Debug.Assert(false, "unexpected StatusValue");
break;
}
#endif
RowBinding.WriteInt32(_offsetStatus, (int)value);
}
internal void SetOffset(int offset) {
if (0 > offset) {
throw ADP.InvalidOffsetValue(offset);
}
_valueBindingOffset = Math.Max(offset, 0);
}
internal void SetSize(int size) {
_valueBindingSize = Math.Max(size, 0);
}
private void SetValueDBNull() {
LengthValue(0);
StatusValue(DBStatus.S_ISNULL);
RowBinding.WriteInt64(ValueOffset, 0); // safe because AlignDataSize forces 8 byte blocks
}
private void SetValueEmpty() {
LengthValue(0);
StatusValue(DBStatus.S_DEFAULT);
RowBinding.WriteInt64(ValueOffset, 0); // safe because AlignDataSize forces 8 byte blocks
}
internal Object Value() {
object value = _value;
if (null == value) {
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.EMPTY:
case NativeDBType.NULL:
value = DBNull.Value;
break;
case NativeDBType.I2:
value = Value_I2(); // Int16
break;
case NativeDBType.I4:
value = Value_I4(); // Int32
break;
case NativeDBType.R4:
value = Value_R4(); // Single
break;
case NativeDBType.R8:
value = Value_R8(); // Double
break;
case NativeDBType.CY:
value = Value_CY(); // Decimal
break;
case NativeDBType.DATE:
value = Value_DATE(); // DateTime
break;
case NativeDBType.BSTR:
value = Value_BSTR(); // String
break;
case NativeDBType.IDISPATCH:
value = Value_IDISPATCH(); // Object
break;
case NativeDBType.ERROR:
value = Value_ERROR(); // Int32
break;
case NativeDBType.BOOL:
value = Value_BOOL(); // Boolean
break;
case NativeDBType.VARIANT:
value = Value_VARIANT(); // Object
break;
case NativeDBType.IUNKNOWN:
value = Value_IUNKNOWN(); // Object
break;
case NativeDBType.DECIMAL:
value = Value_DECIMAL(); // Decimal
break;
case NativeDBType.I1:
value = (short) Value_I1(); // SByte->Int16
break;
case NativeDBType.UI1:
value = Value_UI1(); // Byte
break;
case NativeDBType.UI2:
value = (int) Value_UI2(); // UInt16->Int32
break;
case NativeDBType.UI4:
value = (long) Value_UI4(); // UInt32->Int64
break;
case NativeDBType.I8:
value = Value_I8(); // Int64
break;
case NativeDBType.UI8:
value = (Decimal) Value_UI8(); // UInt64->Decimal
break;
case NativeDBType.FILETIME:
value = Value_FILETIME(); // DateTime
break;
case NativeDBType.GUID:
value = Value_GUID(); // Guid
break;
case NativeDBType.BYTES:
value = Value_BYTES(); // Byte[]
break;
case NativeDBType.WSTR:
value = Value_WSTR(); // String
break;
case NativeDBType.NUMERIC:
value = Value_NUMERIC(); // Decimal
break;
case NativeDBType.DBDATE:
value = Value_DBDATE(); // DateTime
break;
case NativeDBType.DBTIME:
value = Value_DBTIME(); // TimeSpan
break;
case NativeDBType.DBTIMESTAMP:
value = Value_DBTIMESTAMP(); // DateTime
break;
case NativeDBType.PROPVARIANT:
value = Value_VARIANT(); // Object
break;
case NativeDBType.HCHAPTER:
value = Value_HCHAPTER(); // OleDbDataReader
break;
case (NativeDBType.BYREF | NativeDBType.BYTES):
value = Value_ByRefBYTES();
break;
case (NativeDBType.BYREF | NativeDBType.WSTR):
value = Value_ByRefWSTR();
break;
default:
throw ODB.GVtUnknown(DbType);
#if DEBUG
case NativeDBType.STR:
Debug.Assert(false, "should have bound as WSTR");
goto default;
case NativeDBType.VARNUMERIC:
Debug.Assert(false, "should have bound as NUMERIC");
goto default;
case NativeDBType.UDT:
Debug.Assert(false, "UDT binding should not have been encountered");
goto default;
case (NativeDBType.BYREF | NativeDBType.STR):
Debug.Assert(false, "should have bound as BYREF|WSTR");
goto default;
#endif
}
break;
case DBStatus.S_TRUNCATED:
switch(DbType) {
case NativeDBType.BYTES:
value = Value_BYTES();
break;
case NativeDBType.WSTR:
value = Value_WSTR();
break;
case (NativeDBType.BYREF | NativeDBType.BYTES):
value = Value_ByRefBYTES();
break;
case (NativeDBType.BYREF | NativeDBType.WSTR):
value = Value_ByRefWSTR();
break;
default:
throw ODB.GVtUnknown(DbType);
#if DEBUG
case NativeDBType.STR:
Debug.Assert(false, "should have bound as WSTR");
goto default;
case (NativeDBType.BYREF | NativeDBType.STR):
Debug.Assert(false, "should have bound as BYREF|WSTR");
goto default;
#endif
}
break;
case DBStatus.S_ISNULL:
case DBStatus.S_DEFAULT:
value = DBNull.Value;
break;
default:
throw CheckTypeValueStatusValue(); // MDAC 71644
}
_value = value;
}
return value;
}
internal void Value(object value) {
if (null == value) {
SetValueEmpty();
}
else if (Convert.IsDBNull(value)) {
SetValueDBNull();
}
else switch (DbType) {
case NativeDBType.EMPTY:
SetValueEmpty();
break;
case NativeDBType.NULL: // language null - no representation, use DBNull
SetValueDBNull();
break;
case NativeDBType.I2:
Value_I2((Int16) value);
break;
case NativeDBType.I4:
Value_I4((Int32) value);
break;
case NativeDBType.R4:
Value_R4((Single) value);
break;
case NativeDBType.R8:
Value_R8((Double) value);
break;
case NativeDBType.CY:
Value_CY((Decimal) value);
break;
case NativeDBType.DATE:
Value_DATE((DateTime) value);
break;
case NativeDBType.BSTR:
Value_BSTR((String) value);
break;
case NativeDBType.IDISPATCH:
Value_IDISPATCH(value);
break;
case NativeDBType.ERROR:
Value_ERROR((Int32) value);
break;
case NativeDBType.BOOL:
Value_BOOL((Boolean) value);
break;
case NativeDBType.VARIANT:
Value_VARIANT(value);
break;
case NativeDBType.IUNKNOWN:
Value_IUNKNOWN(value);
break;
case NativeDBType.DECIMAL:
Value_DECIMAL((Decimal) value);
break;
case NativeDBType.I1:
if (value is Int16) { // MDAC 60430
Value_I1(Convert.ToSByte((Int16)value, CultureInfo.InvariantCulture));
}
else {
Value_I1((SByte) value);
}
break;
case NativeDBType.UI1:
Value_UI1((Byte) value);
break;
case NativeDBType.UI2:
if (value is Int32) {
Value_UI2(Convert.ToUInt16((Int32)value, CultureInfo.InvariantCulture));
}
else {
Value_UI2((UInt16) value);
}
break;
case NativeDBType.UI4:
if (value is Int64) {
Value_UI4(Convert.ToUInt32((Int64)value, CultureInfo.InvariantCulture));
}
else {
Value_UI4((UInt32) value);
}
break;
case NativeDBType.I8:
Value_I8((Int64) value);
break;
case NativeDBType.UI8:
if (value is Decimal) {
Value_UI8(Convert.ToUInt64((Decimal)value, CultureInfo.InvariantCulture));
}
else {
Value_UI8((UInt64) value);
}
break;
case NativeDBType.FILETIME:
Value_FILETIME((DateTime) value);
break;
case NativeDBType.GUID:
Value_GUID((Guid) value);
break;
case NativeDBType.BYTES:
Value_BYTES((Byte[]) value);
break;
case NativeDBType.WSTR:
if (value is string) {
Value_WSTR((String) value);
}
else {
Value_WSTR((char[]) value);
}
break;
case NativeDBType.NUMERIC:
Value_NUMERIC((Decimal) value);
break;
case NativeDBType.DBDATE:
Value_DBDATE((DateTime) value);
break;
case NativeDBType.DBTIME:
Value_DBTIME((TimeSpan) value);
break;
case NativeDBType.DBTIMESTAMP:
Value_DBTIMESTAMP((DateTime) value);
break;
case NativeDBType.PROPVARIANT:
Value_VARIANT(value);
break;
case (NativeDBType.BYREF | NativeDBType.BYTES):
Value_ByRefBYTES((Byte[]) value);
break;
case (NativeDBType.BYREF | NativeDBType.WSTR):
if (value is string) {
Value_ByRefWSTR((String) value);
}
else {
Value_ByRefWSTR((char[])value);
}
break;
default:
Debug.Assert(false, "unknown DBTYPE");
throw ODB.SVtUnknown(DbType);
#if DEBUG
case NativeDBType.STR:
Debug.Assert(false, "Should have bound as WSTR");
goto default;
case NativeDBType.UDT:
Debug.Assert(false, "UDT binding should not have been encountered");
goto default;
case NativeDBType.HCHAPTER:
Debug.Assert(false, "not allowed to set HCHAPTER");
goto default;
case NativeDBType.VARNUMERIC:
Debug.Assert(false, "should have bound as NUMERIC");
goto default;
case (NativeDBType.BYREF | NativeDBType.STR):
Debug.Assert(false, "should have bound as BYREF|WSTR");
goto default;
#endif
}
}
internal Boolean Value_BOOL() {
Debug.Assert((NativeDBType.BOOL == DbType), "Value_BOOL");
Debug.Assert((DBStatus.S_OK == StatusValue()), "Value_BOOL");
Int16 value = RowBinding.ReadInt16(ValueOffset);
return (0 != value);
}
private void Value_BOOL(Boolean value) {
Debug.Assert((NativeDBType.BOOL == DbType), "Value_BOOL");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteInt16(ValueOffset, (short)(value ? ODB.VARIANT_TRUE : ODB.VARIANT_FALSE));
}
private String Value_BSTR() {
Debug.Assert((NativeDBType.BSTR == DbType), "Value_BSTR");
Debug.Assert((DBStatus.S_OK == StatusValue()), "Value_BSTR");
string value = "";
RowBinding bindings = RowBinding;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
bindings.DangerousAddRef(ref mustRelease);
IntPtr ptr = bindings.ReadIntPtr(ValueOffset);
if (ADP.PtrZero != ptr) {
value = Marshal.PtrToStringBSTR(ptr);
}
}
finally {
if (mustRelease) {
bindings.DangerousRelease();
}
}
return value;
}
private void Value_BSTR(String value) {
Debug.Assert((null != value), "Value_BSTR null");
Debug.Assert((NativeDBType.BSTR == DbType), "Value_BSTR");
LengthValue(value.Length * 2); /* bytecount*/
StatusValue(DBStatus.S_OK);
RowBinding.SetBstrValue(ValueOffset, value);
}
private Byte[] Value_ByRefBYTES() {
Debug.Assert(((NativeDBType.BYREF | NativeDBType.BYTES) == DbType), "Value_ByRefBYTES");
Debug.Assert((DBStatus.S_OK == StatusValue()), "Value_ByRefBYTES");
byte[] value = null;
RowBinding bindings = RowBinding;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
bindings.DangerousAddRef(ref mustRelease);
IntPtr ptr = bindings.ReadIntPtr(ValueOffset);
if (ADP.PtrZero != ptr) {
value = new byte[LengthValue()];
Marshal.Copy(ptr, value, 0, value.Length);
}
}
finally {
if (mustRelease) {
bindings.DangerousRelease();
}
}
return ((null != value) ? value : new byte[0]);
}
private void Value_ByRefBYTES(Byte[] value) {
Debug.Assert(null != value, "Value_ByRefBYTES null");
Debug.Assert((NativeDBType.BYREF | NativeDBType.BYTES) == DbType, "Value_ByRefBYTES");
// we expect the provider/server to apply the silent truncation when binding BY_REF
// if (value.Length < ValueBindingOffset) { throw "Offset must refer to a location within the value" }
int length = ((ValueBindingOffset < value.Length) ? (value.Length - ValueBindingOffset) : 0);
LengthValue(((0 < ValueBindingSize) ? Math.Min(ValueBindingSize, length) : length));
StatusValue(DBStatus.S_OK);
IntPtr ptr = ADP.PtrZero;
if (0 < length) { // avoid pinning empty byte[]
_pinnedBuffer = GCHandle.Alloc(value, GCHandleType.Pinned);
ptr = _pinnedBuffer.AddrOfPinnedObject();
ptr = ADP.IntPtrOffset(ptr, ValueBindingOffset);
}
RowBinding.SetByRefValue(ValueOffset, ptr);
}
private String Value_ByRefWSTR() {
Debug.Assert((NativeDBType.BYREF | NativeDBType.WSTR) == DbType, "Value_ByRefWSTR");
Debug.Assert((DBStatus.S_OK == StatusValue()) || (DBStatus.S_TRUNCATED == StatusValue()), "Value_ByRefWSTR");
string value = "";
RowBinding bindings = RowBinding;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
bindings.DangerousAddRef(ref mustRelease);
IntPtr ptr = bindings.ReadIntPtr(ValueOffset);
if (ADP.PtrZero != ptr) {
int charCount = LengthValue() / 2;
value = Marshal.PtrToStringUni(ptr, charCount);
}
}
finally {
if (mustRelease) {
bindings.DangerousRelease();
}
}
return value;
}
private void Value_ByRefWSTR(String value) {
Debug.Assert(null != value, "Value_ByRefWSTR null");
Debug.Assert((NativeDBType.BYREF | NativeDBType.WSTR) == DbType, "Value_ByRefWSTR");
// we expect the provider/server to apply the silent truncation when binding BY_REF
// if (value.Length < ValueBindingOffset) { throw "Offset must refer to a location within the value" }
int length = ((ValueBindingOffset < value.Length) ? (value.Length - ValueBindingOffset) : 0);
LengthValue(((0 < ValueBindingSize) ? Math.Min(ValueBindingSize, length) : length) * 2); /* charcount->bytecount*/
StatusValue(DBStatus.S_OK);
IntPtr ptr = ADP.PtrZero;
if (0 < length) { // avoid pinning empty string, i.e String.Empty
_pinnedBuffer = GCHandle.Alloc(value, GCHandleType.Pinned);
ptr = _pinnedBuffer.AddrOfPinnedObject();
ptr = ADP.IntPtrOffset(ptr, ValueBindingOffset);
}
RowBinding.SetByRefValue(ValueOffset, ptr);
}
private void Value_ByRefWSTR(char[] value) {
Debug.Assert(null != value, "Value_ByRefWSTR null");
Debug.Assert((NativeDBType.BYREF | NativeDBType.WSTR) == DbType, "Value_ByRefWSTR");
// we expect the provider/server to apply the silent truncation when binding BY_REF
// if (value.Length < ValueBindingOffset) { throw "Offset must refer to a location within the value" }
int length = ((ValueBindingOffset < value.Length) ? (value.Length - ValueBindingOffset) : 0);
LengthValue(((0 < ValueBindingSize) ? Math.Min(ValueBindingSize, length) : length) * 2); /* charcount->bytecount*/
StatusValue(DBStatus.S_OK);
IntPtr ptr = ADP.PtrZero;
if (0 < length) { // avoid pinning empty char[]
_pinnedBuffer = GCHandle.Alloc(value, GCHandleType.Pinned);
ptr = _pinnedBuffer.AddrOfPinnedObject();
ptr = ADP.IntPtrOffset(ptr, ValueBindingOffset);
}
RowBinding.SetByRefValue(ValueOffset, ptr);
}
private Byte[] Value_BYTES() {
Debug.Assert(NativeDBType.BYTES == DbType, "Value_BYTES");
Debug.Assert((DBStatus.S_OK == StatusValue()) || (DBStatus.S_TRUNCATED == StatusValue()), "Value_BYTES");
int byteCount = Math.Min(LengthValue(), ColumnBindingMaxLen);
byte[] value = new byte[byteCount];
RowBinding.ReadBytes(ValueOffset, value, 0, byteCount);
return value;
}
private void Value_BYTES(Byte[] value) {
Debug.Assert(null != value, "Value_BYTES null");
// we silently truncate when the user has specified a given Size
int bytecount = ((ValueBindingOffset < value.Length) ? Math.Min(value.Length - ValueBindingOffset, ColumnBindingMaxLen) : 0); // 70232
LengthValue(bytecount);
StatusValue(DBStatus.S_OK);
if (0 < bytecount) {
RowBinding.WriteBytes(ValueOffset, value, ValueBindingOffset, bytecount);
}
}
private Decimal Value_CY() {
Debug.Assert(NativeDBType.CY == DbType, "Value_CY");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_CY");
return Decimal.FromOACurrency(RowBinding.ReadInt64(ValueOffset));
}
private void Value_CY(Decimal value) {
Debug.Assert(NativeDBType.CY == DbType, "Value_CY");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteInt64(ValueOffset, Decimal.ToOACurrency(value));
}
private DateTime Value_DATE() {
Debug.Assert(NativeDBType.DATE == DbType, "Value_DATE");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_DATE");
return DateTime.FromOADate(RowBinding.ReadDouble(ValueOffset));
}
private void Value_DATE(DateTime value) {
Debug.Assert(NativeDBType.DATE == DbType, "Value_DATE");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteDouble(ValueOffset, value.ToOADate());
}
private DateTime Value_DBDATE() {
Debug.Assert(NativeDBType.DBDATE == DbType, "Value_DBDATE");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_DBDATE");
return RowBinding.ReadDate(ValueOffset);
}
private void Value_DBDATE(DateTime value) {
Debug.Assert(NativeDBType.DBDATE == DbType, "Value_DATE");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteDate(ValueOffset, value);
}
private TimeSpan Value_DBTIME() {
Debug.Assert(NativeDBType.DBTIME == DbType, "Value_DBTIME");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_DBTIME");
return RowBinding.ReadTime(ValueOffset);
}
private void Value_DBTIME(TimeSpan value) {
Debug.Assert(NativeDBType.DBTIME == DbType, "Value_DBTIME");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteTime(ValueOffset, value);
}
private DateTime Value_DBTIMESTAMP() {
Debug.Assert(NativeDBType.DBTIMESTAMP == DbType, "Value_DBTIMESTAMP");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_DBTIMESTAMP");
return RowBinding.ReadDateTime(ValueOffset);
}
private void Value_DBTIMESTAMP(DateTime value) {
Debug.Assert(NativeDBType.DBTIMESTAMP == DbType, "Value_DBTIMESTAMP");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteDateTime(ValueOffset, value);
}
private Decimal Value_DECIMAL() {
Debug.Assert(NativeDBType.DECIMAL == DbType, "Value_DECIMAL");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_DECIMAL");
int[] buffer = new int[4];
RowBinding.ReadInt32Array(ValueOffset, buffer, 0, 4);
return new Decimal(
buffer[2], // low
buffer[3], // mid
buffer[1], // high
(0 != (buffer[0] & unchecked((int)0x80000000))), // sign
unchecked((byte)((buffer[0] & unchecked((int)0x00FF0000)) >> 16))); // scale, MDAC 95080
}
private void Value_DECIMAL(Decimal value) {
Debug.Assert(NativeDBType.DECIMAL == DbType, "Value_DECIMAL");
/* pending breaking change approval
if (_precision < ((System.Data.SqlTypes.SqlDecimal) value).Precision) { // WebData 87236
throw ADP.ParameterValueOutOfRange(value);
}
*/
LengthValue(0);
StatusValue(DBStatus.S_OK);
int[] tmp = Decimal.GetBits(value);
int[] buffer = new int[4] {
tmp[3], tmp[2], tmp[0], tmp[1]
};
RowBinding.WriteInt32Array(ValueOffset, buffer, 0, 4);
}
private Int32 Value_ERROR() {
Debug.Assert(NativeDBType.ERROR == DbType, "Value_ERROR");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_ERROR");
return RowBinding.ReadInt32(ValueOffset);
}
private void Value_ERROR(Int32 value) {
Debug.Assert(NativeDBType.ERROR == DbType, "Value_ERROR");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteInt32(ValueOffset, value);
}
private DateTime Value_FILETIME() {
Debug.Assert(NativeDBType.FILETIME == DbType, "Value_FILETIME");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_FILETIME");
Int64 tmp = RowBinding.ReadInt64(ValueOffset);
return DateTime.FromFileTime(tmp);
}
private void Value_FILETIME(DateTime value) {
Debug.Assert(NativeDBType.FILETIME == DbType, "Value_FILETIME");
LengthValue(0);
StatusValue(DBStatus.S_OK);
Int64 tmp = value.ToFileTime();
RowBinding.WriteInt64(ValueOffset, tmp);
}
internal Guid Value_GUID() {
Debug.Assert(NativeDBType.GUID == DbType, "Value_GUID");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_GUID");
return RowBinding.ReadGuid(ValueOffset);
}
private void Value_GUID(Guid value) {
Debug.Assert(NativeDBType.GUID == DbType, "Value_GUID");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteGuid(ValueOffset, value);
}
internal OleDbDataReader Value_HCHAPTER() {
Debug.Assert(NativeDBType.HCHAPTER == DbType, "Value_HCHAPTER");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_HCHAPTER");
return DataReader().ResetChapter(IndexForAccessor, IndexWithinAccessor, RowBinding, ValueOffset);
}
private SByte Value_I1() {
Debug.Assert(NativeDBType.I1 == DbType, "Value_I1");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_I1");
byte value = RowBinding.ReadByte(ValueOffset);
return unchecked((SByte)value);
}
private void Value_I1(SByte value) {
Debug.Assert(NativeDBType.I1 == DbType, "Value_I1");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteByte(ValueOffset, unchecked((Byte) value));
}
internal Int16 Value_I2() {
Debug.Assert(NativeDBType.I2 == DbType, "Value_I2");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_I2");
return RowBinding.ReadInt16(ValueOffset);
}
private void Value_I2(Int16 value) {
Debug.Assert(NativeDBType.I2 == DbType, "Value_I2");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteInt16(ValueOffset, value);
}
private Int32 Value_I4() {
Debug.Assert(NativeDBType.I4 == DbType, "Value_I4");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_I4");
return RowBinding.ReadInt32(ValueOffset);
}
private void Value_I4(Int32 value) {
Debug.Assert(NativeDBType.I4 == DbType, "Value_I4");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteInt32(ValueOffset, value);
}
private Int64 Value_I8() {
Debug.Assert(NativeDBType.I8 == DbType, "Value_I8");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_I8");
return RowBinding.ReadInt64(ValueOffset);
}
private void Value_I8(Int64 value) {
Debug.Assert(NativeDBType.I8 == DbType, "Value_I8");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteInt64(ValueOffset, value);
}
private object Value_IDISPATCH() {
Debug.Assert(NativeDBType.IDISPATCH == DbType, "Value_IDISPATCH");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_IDISPATCH");
object value;
RowBinding bindings = RowBinding;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
bindings.DangerousAddRef(ref mustRelease);
IntPtr ptr = bindings.ReadIntPtr(ValueOffset);
value = Marshal.GetObjectForIUnknown(ptr);
}
finally {
if (mustRelease) {
bindings.DangerousRelease();
}
}
return value;
}
private void Value_IDISPATCH(object value) {
//
(new System.Security.NamedPermissionSet("FullTrust")).Demand(); // MDAC 80727
Debug.Assert(NativeDBType.IDISPATCH == DbType, "Value_IDISPATCH");
LengthValue(0);
StatusValue(DBStatus.S_OK);
IntPtr ptr = Marshal.GetIDispatchForObject(value); // MDAC 80727
RowBinding.WriteIntPtr(ValueOffset, ptr);
}
private object Value_IUNKNOWN() {
Debug.Assert(NativeDBType.IUNKNOWN == DbType, "Value_IUNKNOWN");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_IUNKNOWN");
object value;
RowBinding bindings = RowBinding;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
bindings.DangerousAddRef(ref mustRelease);
IntPtr ptr = bindings.ReadIntPtr(ValueOffset);
value = Marshal.GetObjectForIUnknown(ptr);
}
finally {
if (mustRelease) {
bindings.DangerousRelease();
}
}
return value;
}
private void Value_IUNKNOWN(object value) {
//
(new System.Security.NamedPermissionSet("FullTrust")).Demand(); // MDAC 80727
Debug.Assert(NativeDBType.IUNKNOWN == DbType, "Value_IUNKNOWN");
LengthValue(0);
StatusValue(DBStatus.S_OK);
IntPtr ptr = Marshal.GetIUnknownForObject(value); // MDAC 80727
RowBinding.WriteIntPtr(ValueOffset, ptr);
}
private Decimal Value_NUMERIC() {
Debug.Assert(NativeDBType.NUMERIC == DbType, "Value_NUMERIC");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_NUMERIC");
return RowBinding.ReadNumeric(ValueOffset);
}
private void Value_NUMERIC(Decimal value) {
Debug.Assert(NativeDBType.NUMERIC == DbType, "Value_NUMERIC");
/* pending breaking change approval
if (_precision < ((System.Data.SqlTypes.SqlDecimal) value).Precision) { // WebData 87236
throw ADP.ParameterValueOutOfRange(value);
}
*/
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteNumeric(ValueOffset, value, ColumnBindingPrecision);
}
private Single Value_R4() {
Debug.Assert(NativeDBType.R4 == DbType, "Value_R4");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_R4");
return RowBinding.ReadSingle(ValueOffset);
}
private void Value_R4(Single value) {
Debug.Assert(NativeDBType.R4 == DbType, "Value_R4");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteSingle(ValueOffset,value);
}
private Double Value_R8() {
Debug.Assert(NativeDBType.R8 == DbType, "Value_R8");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_R8");
return RowBinding.ReadDouble(ValueOffset);
}
private void Value_R8(Double value) {
Debug.Assert(NativeDBType.R8 == DbType, "Value_I4");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteDouble(ValueOffset, value);
}
private Byte Value_UI1() {
Debug.Assert(NativeDBType.UI1 == DbType, "Value_UI1");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_UI1");
return RowBinding.ReadByte(ValueOffset);
}
private void Value_UI1(Byte value) {
Debug.Assert(NativeDBType.UI1 == DbType, "Value_UI1");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteByte(ValueOffset, value);
}
internal UInt16 Value_UI2() {
Debug.Assert(NativeDBType.UI2 == DbType, "Value_UI2");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_UI2");
return unchecked((UInt16) RowBinding.ReadInt16(ValueOffset));
}
private void Value_UI2(UInt16 value) {
Debug.Assert(NativeDBType.UI2 == DbType, "Value_UI2");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteInt16(ValueOffset, unchecked((Int16) value));
}
internal UInt32 Value_UI4() {
Debug.Assert(NativeDBType.UI4 == DbType, "Value_UI4");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_UI4");
return unchecked((UInt32) RowBinding.ReadInt32(ValueOffset));
}
private void Value_UI4(UInt32 value) {
Debug.Assert(NativeDBType.UI4 == DbType, "Value_UI4");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteInt32(ValueOffset, unchecked((Int32) value));
}
internal UInt64 Value_UI8() {
Debug.Assert(NativeDBType.UI8 == DbType, "Value_UI8");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_UI8");
return unchecked((UInt64) RowBinding.ReadInt64(ValueOffset));
}
private void Value_UI8(UInt64 value) {
Debug.Assert(NativeDBType.UI8 == DbType, "Value_UI8");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.WriteInt64(ValueOffset, unchecked((Int64) value));
}
private String Value_WSTR() {
Debug.Assert(NativeDBType.WSTR == DbType, "Value_WSTR");
Debug.Assert((DBStatus.S_OK == StatusValue()) || (DBStatus.S_TRUNCATED == StatusValue()), "Value_WSTR");
Debug.Assert(2 < ColumnBindingMaxLen, "Value_WSTR");
int byteCount = Math.Min(LengthValue(), ColumnBindingMaxLen-2);
return RowBinding.PtrToStringUni(ValueOffset, byteCount / 2);
}
private void Value_WSTR(String value) {
Debug.Assert(null != value, "Value_BYTES null");
Debug.Assert(NativeDBType.WSTR == DbType, "Value_WSTR");
// we silently truncate when the user has specified a given Size
int charCount = ((ValueBindingOffset < value.Length) ? Math.Min(value.Length - ValueBindingOffset, (ColumnBindingMaxLen-2)/2) : 0); // 70232
LengthValue(charCount*2);
StatusValue(DBStatus.S_OK);
if (0 < charCount) {
char[] chars = value.ToCharArray(ValueBindingOffset, charCount);
RowBinding.WriteCharArray(ValueOffset, chars, ValueBindingOffset, charCount);
}
}
private void Value_WSTR(char[] value) {
Debug.Assert(null != value, "Value_BYTES null");
Debug.Assert(NativeDBType.WSTR == DbType, "Value_WSTR");
// we silently truncate when the user has specified a given Size
int charCount = ((ValueBindingOffset < value.Length) ? Math.Min(value.Length - ValueBindingOffset, (ColumnBindingMaxLen-2)/2) : 0); // 70232
LengthValue(charCount*2);
StatusValue(DBStatus.S_OK);
if (0 < charCount) {
RowBinding.WriteCharArray(ValueOffset, value, ValueBindingOffset, charCount);
}
}
private object Value_VARIANT() {
Debug.Assert((NativeDBType.VARIANT == DbType) || (NativeDBType.PROPVARIANT == DbType), "Value_VARIANT");
Debug.Assert(DBStatus.S_OK == StatusValue(), "Value_VARIANT");
return RowBinding.GetVariantValue(ValueOffset);
}
private void Value_VARIANT(object value) {
Debug.Assert((NativeDBType.VARIANT == DbType) || (NativeDBType.PROPVARIANT == DbType), "Value_VARIANT");
LengthValue(0);
StatusValue(DBStatus.S_OK);
RowBinding.SetVariantValue(ValueOffset, value);
}
internal Boolean ValueBoolean() {
Boolean value;
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.BOOL:
value = Value_BOOL();
break;
case NativeDBType.VARIANT:
value = (Boolean) ValueVariant();
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(Boolean));
}
return value;
}
internal byte[] ValueByteArray() {
byte[] value = (byte[]) _value;
if (null == value) {
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.BYTES:
value = Value_BYTES(); // String
break;
case NativeDBType.VARIANT:
value = (byte[])ValueVariant(); // Object
break;
case (NativeDBType.BYREF | NativeDBType.BYTES):
value = Value_ByRefBYTES();
break;
default:
throw ODB.ConversionRequired();
}
break;
case DBStatus.S_TRUNCATED:
switch(DbType) {
case NativeDBType.BYTES:
value = Value_BYTES();
break;
case (NativeDBType.BYREF | NativeDBType.BYTES):
value = Value_ByRefBYTES();
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(byte[]));
}
_value = value;
}
return value;
}
internal Byte ValueByte() {
Byte value;
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.UI1:
value = Value_UI1();
break;
case NativeDBType.VARIANT:
value = (Byte) ValueVariant();
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(Byte));
}
return value;
}
internal OleDbDataReader ValueChapter() {
OleDbDataReader value = (OleDbDataReader) _value;
if (null == value) {
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.HCHAPTER:
value = Value_HCHAPTER(); // OleDbDataReader
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(String));
}
_value = value;
}
return value;
}
internal DateTime ValueDateTime() {
DateTime value;
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.DATE:
value = Value_DATE();
break;
case NativeDBType.DBDATE:
value = Value_DBDATE();
break;
case NativeDBType.DBTIMESTAMP:
value = Value_DBTIMESTAMP();
break;
case NativeDBType.FILETIME:
value = Value_FILETIME();
break;
case NativeDBType.VARIANT:
value = (DateTime) ValueVariant();
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(Int16));
}
return value;
}
internal Decimal ValueDecimal() {
Decimal value;
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.CY:
value = Value_CY();
break;
case NativeDBType.DECIMAL:
value = Value_DECIMAL();
break;
case NativeDBType.NUMERIC:
value = Value_NUMERIC();
break;
case NativeDBType.UI8:
value = (Decimal)Value_UI8();
break;
case NativeDBType.VARIANT:
value = (Decimal) ValueVariant();
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(Int16));
}
return value;
}
internal Guid ValueGuid() {
Guid value;
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.GUID:
value = Value_GUID();
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(Int16));
}
return value;
}
internal Int16 ValueInt16() {
Int16 value;
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.I2:
value = Value_I2();
break;
case NativeDBType.I1:
value = (Int16) Value_I1();
break;
case NativeDBType.VARIANT:
object variant = ValueVariant();
if (variant is SByte) {
value = (Int16)(SByte) variant;
}
else {
value = (Int16) variant;
}
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(Int16));
}
return value;
}
internal Int32 ValueInt32() {
Int32 value;
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.I4:
value = Value_I4();
break;
case NativeDBType.UI2:
value = (Int32) Value_UI2();
break;
case NativeDBType.VARIANT:
object variant = ValueVariant();
if (variant is UInt16) {
value = (Int32)(UInt16) variant;
}
else {
value = (Int32) variant;
}
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(Int32));
}
return value;
}
internal Int64 ValueInt64() {
Int64 value;
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.I8:
value = Value_I8();
break;
case NativeDBType.UI4:
value = (Int64) Value_UI4();
break;
case NativeDBType.VARIANT:
object variant = ValueVariant();
if (variant is UInt32) {
value = (Int64)(UInt32) variant;
}
else {
value = (Int64) variant;
}
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(Int64));
}
return value;
}
internal Single ValueSingle() {
Single value;
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.R4:
value = Value_R4();
break;
case NativeDBType.VARIANT:
value = (Single) ValueVariant();
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(Single));
}
return value;
}
internal Double ValueDouble() {
Double value;
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.R8:
value = Value_R8();
break;
case NativeDBType.VARIANT:
value = (Double) ValueVariant();
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(Double));
}
return value;
}
internal string ValueString() {
string value = (String) _value;
if (null == value) {
switch(StatusValue()) {
case DBStatus.S_OK:
switch(DbType) {
case NativeDBType.BSTR:
value = Value_BSTR(); // String
break;
case NativeDBType.VARIANT:
value = (String) ValueVariant(); // Object
break;
case NativeDBType.WSTR:
value = Value_WSTR(); // String
break;
case (NativeDBType.BYREF | NativeDBType.WSTR):
value = Value_ByRefWSTR();
break;
default:
throw ODB.ConversionRequired();
}
break;
case DBStatus.S_TRUNCATED:
switch(DbType) {
case NativeDBType.WSTR:
value = Value_WSTR();
break;
case (NativeDBType.BYREF | NativeDBType.WSTR):
value = Value_ByRefWSTR();
break;
default:
throw ODB.ConversionRequired();
}
break;
default:
throw CheckTypeValueStatusValue(typeof(String));
}
_value = value;
}
return value;
}
private object ValueVariant() {
object value = _value;
if (null == value) {
value = Value_VARIANT();
_value = value;
}
return value;
}
private Exception CheckTypeValueStatusValue() { // MDAC 71644
return CheckTypeValueStatusValue(ExpectedType);
}
private Exception CheckTypeValueStatusValue(Type expectedType) { // MDAC 71644
switch (StatusValue()) {
case DBStatus.S_OK:
Debug.Assert(false, "CheckStatusValue: unhandled data with ok status");
goto case DBStatus.E_CANTCONVERTVALUE;
case DBStatus.S_TRUNCATED:
Debug.Assert(false, "CheckStatusValue: unhandled data with truncated status");
goto case DBStatus.E_CANTCONVERTVALUE;
case DBStatus.E_BADACCESSOR:
return ODB.BadAccessor();
case DBStatus.E_CANTCONVERTVALUE:
return ODB.CantConvertValue(); //
case DBStatus.S_ISNULL: // database null
return ADP.InvalidCast(); //
case DBStatus.E_SIGNMISMATCH:
return ODB.SignMismatch(expectedType);
case DBStatus.E_DATAOVERFLOW:
return ODB.DataOverflow(expectedType);
case DBStatus.E_CANTCREATE:
return ODB.CantCreate(expectedType);
case DBStatus.E_UNAVAILABLE:
return ODB.Unavailable(expectedType);
default:
return ODB.UnexpectedStatusValue(StatusValue());
}
}
}
}
|