static internal int GetLength(
NativeBuffer buffer,
int lengthOffset,
MetaType metaType
)
{
// Get the length of the data bound
int length;
HandleRef lengthBuffer = buffer.PtrOffset(lengthOffset);
// Oracle only will write two bytes of length, but LONG data types
// can exceed that amount; our piecewise callbacks will write a
// full DWORD of length, so we need to get the full length for them,
// but if we do that for all the other types, we'll be reading
// un-initialized memory and bad things happen.
if (metaType.IsLong)
{
length = Marshal.ReadInt32((IntPtr)lengthBuffer);
}
else
{
length = (int)Marshal.ReadInt16((IntPtr)lengthBuffer);
}
return(length);
}
internal void GetNames()
{
this._lob.AssertConnectionIsOpen();
short num5 = this.Connection.EnvironmentHandle.IsUnicode ? ((short) 2) : ((short) 1);
ushort num = (ushort) (30 * num5);
int offset = num;
ushort num3 = (ushort) (0xff * num5);
NativeBuffer scratchBuffer = this.Connection.GetScratchBuffer(num + num3);
bool success = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
scratchBuffer.DangerousAddRef(ref success);
int rc = TracedNativeMethods.OCILobFileGetName(this.Connection.EnvironmentHandle, this.ErrorHandle, this.Descriptor, scratchBuffer.DangerousGetDataPtr(), ref num, scratchBuffer.DangerousGetDataPtr(offset), ref num3);
if (rc != 0)
{
this.Connection.CheckError(this.ErrorHandle, rc);
}
this._directoryAlias = this.Connection.GetString(scratchBuffer.ReadBytes(0, num));
this._fileName = this.Connection.GetString(scratchBuffer.ReadBytes(offset, num3));
}
finally
{
if (success)
{
scratchBuffer.DangerousRelease();
}
}
}
internal void GetNames()
{
_lob.AssertConnectionIsOpen();
int charSize = (Connection.EnvironmentHandle.IsUnicode) ? 2 : 1;
short directoryAliasLength = (short)(charSize * 30);
short fileAliasLength = (short)(charSize * 255);
NativeBuffer buffer = Connection.ScratchBuffer;
Debug.Assert(buffer.Length > (directoryAliasLength + fileAliasLength), "connection's scratch buffer is too small");
HandleRef directoryAlias = buffer.Ptr;
HandleRef fileAlias = buffer.PtrOffset(directoryAliasLength);
int rc = TracedNativeMethods.OCILobFileGetName(
Connection.EnvironmentHandle,
ErrorHandle,
Descriptor,
directoryAlias,
ref directoryAliasLength,
fileAlias,
ref fileAliasLength
);
if (0 != rc)
{
Connection.CheckError(ErrorHandle, rc);
}
_directoryAlias = Connection.GetString((IntPtr)directoryAlias, directoryAliasLength, false);
_fileName = Connection.GetString((IntPtr)fileAlias, fileAliasLength, false);
GC.KeepAlive(buffer);
}
internal OracleBinary(NativeBuffer buffer, int valueOffset, int lengthOffset, MetaType metaType)
{
int byteCount = GetLength(buffer, lengthOffset, metaType);
this._value = new byte[byteCount];
GetBytes(buffer, valueOffset, metaType, 0, this._value, 0, byteCount);
}
// (internal) construct from a row/parameter binding
internal OracleTimeSpan(
NativeBuffer buffer,
int valueOffset) : this(true)
{
_value = new byte[11];
Marshal.Copy((IntPtr)buffer.PtrOffset(valueOffset), _value, 0, 11);
}
internal static int GetChars(NativeBuffer buffer, int valueOffset, int lengthOffset, MetaType metaType, OracleConnection connection, bool boundAsUCS2, int sourceOffset, char[] destinationBuffer, int destinationOffset, int charCount)
{
bool success = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
buffer.DangerousAddRef(ref success);
if (boundAsUCS2)
{
if (!metaType.IsLong)
{
Marshal.Copy(buffer.DangerousGetDataPtrWithBaseOffset(valueOffset + (System.Data.Common.ADP.CharSize * sourceOffset)), destinationBuffer, destinationOffset, charCount);
return(charCount);
}
NativeBuffer_LongColumnData.CopyOutOfLineChars(buffer.ReadIntPtr(valueOffset), sourceOffset, destinationBuffer, destinationOffset, charCount);
return(charCount);
}
string str = MarshalToString(buffer, valueOffset, lengthOffset, metaType, connection, boundAsUCS2, false);
int length = str.Length;
int num = ((sourceOffset + charCount) > length) ? (length - sourceOffset) : charCount;
Buffer.BlockCopy(str.ToCharArray(sourceOffset, num), 0, destinationBuffer, destinationOffset * System.Data.Common.ADP.CharSize, num * System.Data.Common.ADP.CharSize);
charCount = num;
}
finally
{
if (success)
{
buffer.DangerousRelease();
}
}
return(charCount);
}
internal static int MarshalToNative(object value, NativeBuffer buffer, int offset, OracleConnection connection)
{
byte[] buffer2;
if (value is OracleNumber)
{
buffer2 = ((OracleNumber)value)._value;
}
else
{
OciErrorHandle errorHandle = connection.ErrorHandle;
buffer2 = new byte[0x16];
if (value is decimal)
{
FromDecimal(errorHandle, (decimal)value, buffer2);
}
else if (value is int)
{
FromInt32(errorHandle, (int)value, buffer2);
}
else if (value is long)
{
FromInt64(errorHandle, (long)value, buffer2);
}
else
{
FromDouble(errorHandle, (double)value, buffer2);
}
}
buffer.WriteBytes(offset, buffer2, 0, 0x16);
return(0x16);
}
internal static int GetLength(NativeBuffer buffer, int lengthOffset, MetaType metaType)
{
if (metaType.IsLong)
{
return(buffer.ReadInt32(lengthOffset));
}
return(buffer.ReadInt16(lengthOffset));
}
internal string PtrToString(NativeBuffer buf)
{
if (this.IsUnicode)
{
return(buf.PtrToStringUni(0));
}
return(buf.PtrToStringAnsi(0));
}
// (internal) construct from a row/parameter binding
internal OracleDateTime(
NativeBuffer buffer,
int valueOffset,
MetaType metaType,
OracleConnection connection)
{
_value = GetBytes(buffer, valueOffset, metaType, connection);
}
static internal int GetChars(
NativeBuffer buffer,
int valueOffset,
int lengthOffset,
MetaType metaType,
OracleConnection connection, // See MDAC #78258 for reason.
bool boundAsUCS2, // See MDAC #78258 for reason.
int sourceOffset,
char[] destinationBuffer,
int destinationOffset,
int charCount
)
{
// This static method allows the GetChars type getter to do it's job
// without having to marshal the entire value into managed space.
if (boundAsUCS2)
{
HandleRef sourceBuffer;
if (!metaType.IsLong)
{
sourceBuffer = buffer.PtrOffset(valueOffset + (ADP.CharSize * sourceOffset));
}
else
{
// Long values are bound out-of-line, which means we have
// to do this the hard way...
sourceBuffer = buffer.PtrOffset(valueOffset);
IntPtr longBuffer = Marshal.ReadIntPtr((IntPtr)sourceBuffer);
if (0 != sourceOffset)
{
longBuffer = new IntPtr(longBuffer.ToInt64() + (long)(ADP.CharSize * sourceOffset));
}
HandleRef newSourceBuffer = new HandleRef(sourceBuffer.Wrapper, longBuffer);
sourceBuffer = newSourceBuffer;
}
Marshal.Copy((IntPtr)sourceBuffer, destinationBuffer, destinationOffset, charCount);
}
else
{
// In the odd case that we don't have a Unicode value (see MDAC #78258
// for the reason) we have to do this the hard way -- get the full value,
// then copy the data...
string value = MarshalToString(buffer, valueOffset, lengthOffset, metaType, connection, boundAsUCS2, false);
int valueLength = value.Length;
int resultLength = (sourceOffset + charCount) > valueLength ? valueLength - sourceOffset : charCount;
char[] result = value.ToCharArray(sourceOffset, resultLength);
Buffer.BlockCopy(result, 0, destinationBuffer, (destinationOffset * ADP.CharSize), (resultLength * ADP.CharSize));
charCount = resultLength;
}
GC.KeepAlive(buffer);
return(charCount);
}
internal static int MarshalToInt32(NativeBuffer buffer, int valueOffset)
{
byte[] buffer2 = buffer.ReadBytes(valueOffset, 5);
int num3 = ((((buffer2[0] << 0x18) | (buffer2[1] << 0x10)) | (buffer2[2] << 8)) | buffer2[3]) - ((int)0x80000000L);
int num2 = buffer2[4] - 60;
int monthSpan = (num3 * 12) + num2;
AssertValid(monthSpan);
return(monthSpan);
}
internal void Dispose()
{
NativeBuffer.SafeDispose(ref this._longBuffer);
OciLobLocator.SafeDispose(ref this._lobLocator);
OciHandle.SafeDispose(ref this._describeHandle);
this._columnName = null;
this._metaType = null;
this._callback = null;
this._connection = null;
}
internal static int GetBytes(NativeBuffer buffer, int valueOffset, MetaType metaType, int sourceOffset, byte[] destinationBuffer, int destinationOffset, int byteCount)
{
if (!metaType.IsLong)
{
buffer.ReadBytes(valueOffset + sourceOffset, destinationBuffer, destinationOffset, byteCount);
return(byteCount);
}
NativeBuffer_LongColumnData.CopyOutOfLineBytes(buffer.ReadIntPtr(valueOffset), sourceOffset, destinationBuffer, destinationOffset, byteCount);
return(byteCount);
}
internal static byte[] GetBytesFromBuffer(NativeBuffer buffer, int valueOffset, int lengthOffset, MetaType metaType, OracleConnection connection)
{
uint num2;
OCI.DATATYPE ociType = metaType.OciType;
short length = buffer.ReadInt16(lengthOffset);
OCI.DATATYPE datatype = ociType;
if (datatype == OCI.DATATYPE.DATE)
{
num2 = 7;
}
else if (datatype == OCI.DATATYPE.INT_TIMESTAMP)
{
num2 = 11;
}
else if (datatype == OCI.DATATYPE.INT_TIMESTAMP_LTZ)
{
num2 = 13;
}
else
{
num2 = 13;
}
byte[] destination = new byte[num2];
buffer.ReadBytes(valueOffset, destination, 0, length);
if (OCI.DATATYPE.INT_TIMESTAMP_LTZ == ociType)
{
TimeSpan serverTimeZoneAdjustmentToUTC = connection.ServerTimeZoneAdjustmentToUTC;
destination[11] = (byte)(serverTimeZoneAdjustmentToUTC.Hours + 20);
destination[12] = (byte)(serverTimeZoneAdjustmentToUTC.Minutes + 60);
return(destination);
}
if ((OCI.DATATYPE.INT_TIMESTAMP_TZ == ociType) && (0x80 < destination[11]))
{
sbyte num3;
sbyte num4;
OciIntervalDescriptor reftz = new OciIntervalDescriptor(connection.EnvironmentHandle);
OciDateTimeDescriptor datetime = new OciDateTimeDescriptor(connection.EnvironmentHandle, OCI.HTYPE.OCI_DTYPE_TIMESTAMP_TZ);
int rc = System.Data.Common.UnsafeNativeMethods.OCIDateTimeFromArray(connection.EnvironmentHandle, connection.ErrorHandle, destination, num2, 0xbc, datetime, reftz, 0);
if (rc != 0)
{
connection.CheckError(connection.ErrorHandle, rc);
}
rc = System.Data.Common.UnsafeNativeMethods.OCIDateTimeGetTimeZoneOffset(connection.EnvironmentHandle, connection.ErrorHandle, datetime, out num4, out num3);
if (rc != 0)
{
connection.CheckError(connection.ErrorHandle, rc);
}
destination[11] = (byte)(num4 + 20);
destination[12] = (byte)(num3 + 60);
}
return(destination);
}
static internal TimeSpan MarshalToTimeSpan(
NativeBuffer buffer,
int valueOffset)
{
byte[] rawValue = new byte[11];
Marshal.Copy((IntPtr)buffer.PtrOffset(valueOffset), rawValue, 0, 11);
TimeSpan result = ToTimeSpan(rawValue);
return(result);
}
static internal DateTime MarshalToDateTime(
NativeBuffer buffer,
int valueOffset,
MetaType metaType,
OracleConnection connection)
{
byte[] rawValue = GetBytes(buffer, valueOffset, metaType, connection);
DateTime result = ToDateTime(rawValue);
return(result);
}
// (internal) construct from a row/parameter binding
internal OracleString(
NativeBuffer buffer,
int valueOffset,
int lengthOffset,
MetaType metaType,
OracleConnection connection, // See MDAC #78258 for reason.
bool boundAsUCS2, // See MDAC #78258 for reason.
bool outputParameterBinding // oracle has inconsistent behavior for output parameters.
)
{
_value = MarshalToString(buffer, valueOffset, lengthOffset, metaType, connection, boundAsUCS2, outputParameterBinding);
}
internal void FixupLongValueLength(NativeBuffer buffer)
{
if ((this._longBuffer != null) && (-1 == this._longLength))
{
this._longLength = this._longBuffer.TotalLengthInBytes;
if (this._bindAsUTF16)
{
this._longLength /= 2;
}
buffer.WriteInt32(this._lengthOffset, this._longLength);
}
}
internal void PostExecute(NativeBuffer parameterBuffer, OracleConnection connection)
{
OracleParameter parameter = this.Parameter;
if (IsDirection(parameter, ParameterDirection.Output) || IsDirection(parameter, ParameterDirection.ReturnValue))
{
bool needCLSType = true;
if (IsDirection(parameter, ParameterDirection.Input) && (parameter.Value is INullable))
{
needCLSType = false;
}
parameter.Value = this.GetOutputValue(parameterBuffer, connection, needCLSType);
}
}
internal static int oermsg(short rcode, NativeBuffer buf)
{
if (Bid.AdvancedOn)
{
Bid.Trace("<oc.oermsg|ADV|OCI> rcode=%d\n", rcode);
}
int num = System.Data.Common.UnsafeNativeMethods.oermsg(rcode, buf);
if (Bid.AdvancedOn)
{
Bid.Trace("<oc.oermsg|ADV|OCI|RET> rc=%d\n", num);
}
return(num);
}
internal static int OCIServerVersion(OciHandle hndlp, OciHandle errhp, NativeBuffer bufp)
{
if (Bid.AdvancedOn)
{
Bid.Trace("<oc.OCIServerVersion|ADV|OCI> hndlp=0x%-07Ix errhp=0x%-07Ix bufp=0x%-07Ix bufsz=%d hndltype=%d{OCI.HTYPE}\n", OciHandle.HandleValueToTrace(hndlp), OciHandle.HandleValueToTrace(errhp), NativeBuffer.HandleValueToTrace(bufp), bufp.Length, (int)hndlp.HandleType);
}
int num = System.Data.Common.UnsafeNativeMethods.OCIServerVersion(hndlp, errhp, bufp, (uint)bufp.Length, (byte)hndlp.HandleType);
if (Bid.AdvancedOn)
{
Bid.Trace("<oc.OCIServerVersion|ADV|OCI|RET> rc=%d\n%ls\n\n", num, hndlp.PtrToString(bufp));
}
return(num);
}
internal static int GetLength(NativeBuffer buffer, int lengthOffset, MetaType metaType)
{
int num;
if (metaType.IsLong)
{
num = buffer.ReadInt32(lengthOffset);
}
else
{
num = buffer.ReadInt16(lengthOffset);
}
GC.KeepAlive(buffer);
return(num);
}
internal NativeBuffer GetScratchBuffer(int minSize)
{
NativeBuffer buffer = this._scratchBuffer;
if ((buffer == null) || (buffer.Length < minSize))
{
if (buffer != null)
{
buffer.Dispose();
}
buffer = new NativeBuffer_ScratchBuffer(minSize);
this._scratchBuffer = buffer;
}
return(buffer);
}
internal static int MarshalToNative(object value, NativeBuffer buffer, int offset)
{
byte[] buffer2;
if (value is OracleTimeSpan)
{
buffer2 = ((OracleTimeSpan)value)._value;
}
else
{
TimeSpan span = (TimeSpan)value;
buffer2 = new byte[11];
Pack(buffer2, span.Days, span.Hours, span.Minutes, span.Seconds, ((int)(span.Ticks % 0x989680L)) * 100);
}
buffer.WriteBytes(offset, buffer2, 0, 11);
return(11);
}
internal static int MarshalToNative(object value, int offset, int size, NativeBuffer buffer, int bufferOffset, OCI.DATATYPE ociType, bool bindAsUCS2)
{
string str;
string str2;
Encoding encoding = bindAsUCS2 ? Encoding.Unicode : Encoding.UTF8;
if (value is OracleString)
{
str = ((OracleString)value)._value;
}
else
{
str = (string)value;
}
if ((offset == 0) && (size == 0))
{
str2 = str;
}
else if ((size == 0) || ((offset + size) > str.Length))
{
str2 = str.Substring(offset);
}
else
{
str2 = str.Substring(offset, size);
}
byte[] bytes = encoding.GetBytes(str2);
int length = bytes.Length;
int num3 = length;
if (length != 0)
{
int num2 = length;
if (bindAsUCS2)
{
num2 /= 2;
}
if (OCI.DATATYPE.LONGVARCHAR == ociType)
{
buffer.WriteInt32(bufferOffset, num2);
bufferOffset += 4;
num3 += 4;
}
buffer.WriteBytes(bufferOffset, bytes, 0, length);
}
return(num3);
}
static internal byte[] GetBytes(
NativeBuffer buffer,
int valueOffset,
MetaType metaType,
OracleConnection connection)
{
// Static method to return the raw data bytes from the row/parameter
// buffer, taking the binding type into account and adjusting it for
// the server time zones, as appropriate.
int ociBytes;
OCI.DATATYPE ociType = metaType.OciType;
switch (ociType)
{
case OCI.DATATYPE.DATE:
ociBytes = x_DATE_Length;
break;
case OCI.DATATYPE.INT_TIMESTAMP:
ociBytes = x_TIMESTAMP_Length;
break;
case OCI.DATATYPE.INT_TIMESTAMP_LTZ:
ociBytes = x_TIMESTAMP_WITH_TIMEZONE_Length;
break;
default:
Debug.Assert(OCI.DATATYPE.INT_TIMESTAMP_TZ == ociType, "unrecognized type");
ociBytes = x_TIMESTAMP_WITH_TIMEZONE_Length;
break;
}
byte[] result = new byte[ociBytes];
Marshal.Copy((IntPtr)buffer.PtrOffset(valueOffset), result, 0, ociBytes);
if (OCI.DATATYPE.INT_TIMESTAMP_LTZ == ociType)
{
TimeSpan tzadjust = connection.ServerTimeZoneAdjustmentToUTC;
result[11] = (byte)(tzadjust.Hours + 20);
result[12] = (byte)(tzadjust.Minutes + 60);
}
return(result);
}
internal static int OCIRowidToChar(OciHandle rowidDesc, NativeBuffer outbfp, ref int bufferLength, OciHandle errhp)
{
ushort outbflp = (ushort)bufferLength;
if (Bid.AdvancedOn)
{
Bid.Trace("<oc.OCIRowidToChar|ADV|OCI> rowidDesc=0x%-07Ix outbfp=0x%-07Ix outbflp=%d, errhp=0x%-07Ix\n", OciHandle.HandleValueToTrace(rowidDesc), NativeBuffer.HandleValueToTrace(outbfp), outbfp.Length, OciHandle.HandleValueToTrace(errhp));
}
int num = System.Data.Common.UnsafeNativeMethods.OCIRowidToChar(rowidDesc, outbfp, ref outbflp, errhp);
bufferLength = outbflp;
if (Bid.AdvancedOn)
{
Bid.Trace("<oc.OCIRowidToChar|ADV|OCI|RET> outbfp='%ls' rc=%d\n", outbfp.PtrToStringAnsi(0, outbflp), num);
}
return(num);
}
// (internal) construct from a row/parameter binding
internal OracleBinary(
NativeBuffer buffer,
int valueOffset,
int lengthOffset,
MetaType metaType)
{
int valueLength = GetLength(buffer, lengthOffset, metaType);
_value = new byte[valueLength];
GetBytes(buffer,
valueOffset,
metaType,
0,
_value,
0,
valueLength);
}
internal static int MarshalDateToNative(object value, NativeBuffer buffer, int offset, OCI.DATATYPE ociType, OracleConnection connection)
{
byte[] buffer2;
if (value is OracleDateTime)
{
buffer2 = ((OracleDateTime)value)._value;
}
else
{
DateTime time = (DateTime)value;
buffer2 = new byte[11];
Pack(buffer2, time.Year, time.Month, time.Day, time.Hour, time.Minute, time.Second, 0);
}
int length = 7;
buffer.WriteBytes(offset, buffer2, 0, length);
return(length);
}
public override void Dispose()
{
this.Deactivate();
OciEnlistContext.SafeDispose(ref this._enlistContext);
OciHandle.SafeDispose(ref this._sessionHandle);
OciHandle.SafeDispose(ref this._serviceContextHandle);
OciHandle.SafeDispose(ref this._serverHandle);
OciHandle.SafeDispose(ref this._errorHandle);
OciHandle.SafeDispose(ref this._environmentHandle);
if (this._scratchBuffer != null)
{
this._scratchBuffer.Dispose();
}
this._scratchBuffer = null;
this._encodingDatabase = null;
this._encodingNational = null;
this._transaction = null;
this._serverVersionString = null;
base.Dispose();
}
internal NativeBuffer GetScratchBuffer(int minSize)
{
NativeBuffer buffer = this._scratchBuffer;
if ((buffer == null) || (buffer.Length < minSize))
{
if (buffer != null)
{
buffer.Dispose();
}
buffer = new NativeBuffer_ScratchBuffer(minSize);
this._scratchBuffer = buffer;
}
return buffer;
}
