static MetaType()
{
oracleTypeMetaType[1] = new MetaType(System.Data.DbType.Binary, System.Data.OracleClient.OracleType.BFile, OCI.DATATYPE.BFILE, "BFILE", typeof(byte[]), typeof(OracleBFile), IntPtr.Size, IntPtr.Size, false);
oracleTypeMetaType[2] = new MetaType(System.Data.DbType.Binary, System.Data.OracleClient.OracleType.Blob, OCI.DATATYPE.BLOB, "BLOB", typeof(byte[]), typeof(OracleLob), IntPtr.Size, IntPtr.Size, false);
oracleTypeMetaType[3] = dbTypeMetaType[0x16];
oracleTypeMetaType[4] = new MetaType(System.Data.DbType.AnsiString, System.Data.OracleClient.OracleType.Clob, OCI.DATATYPE.CLOB, "CLOB", typeof(string), typeof(OracleLob), IntPtr.Size, IntPtr.Size, false);
oracleTypeMetaType[5] = new MetaType(System.Data.DbType.Object, System.Data.OracleClient.OracleType.Cursor, OCI.DATATYPE.RSET, "REF CURSOR", typeof(object), typeof(object), IntPtr.Size, IntPtr.Size, false);
oracleTypeMetaType[6] = dbTypeMetaType[6];
oracleTypeMetaType[8] = new MetaType(System.Data.DbType.Int32, System.Data.OracleClient.OracleType.IntervalYearToMonth, OCI.DATATYPE.INT_INTERVAL_YM, "INTERVAL YEAR TO MONTH", typeof(int), typeof(OracleMonthSpan), 5, 5, false);
oracleTypeMetaType[7] = new MetaType(System.Data.DbType.Object, System.Data.OracleClient.OracleType.IntervalDayToSecond, OCI.DATATYPE.INT_INTERVAL_DS, "INTERVAL DAY TO SECOND", typeof(TimeSpan), typeof(OracleTimeSpan), 11, 11, false);
oracleTypeMetaType[9] = new MetaType(System.Data.DbType.Binary, System.Data.OracleClient.OracleType.LongRaw, OCI.DATATYPE.LONGRAW, "LONG RAW", typeof(byte[]), typeof(OracleBinary), 0x7fffffff, 0x7fbc, false);
oracleTypeMetaType[10] = new MetaType(System.Data.DbType.AnsiString, System.Data.OracleClient.OracleType.LongVarChar, OCI.DATATYPE.LONG, "LONG", typeof(string), typeof(OracleString), 0x7fffffff, 0x7fbc, false);
oracleTypeMetaType[11] = dbTypeMetaType[0x17];
oracleTypeMetaType[12] = new MetaType(System.Data.DbType.String, System.Data.OracleClient.OracleType.NClob, OCI.DATATYPE.CLOB, "NCLOB", typeof(string), typeof(OracleLob), IntPtr.Size, IntPtr.Size, true);
oracleTypeMetaType[13] = dbTypeMetaType[0x15];
oracleTypeMetaType[14] = dbTypeMetaType[0x10];
oracleTypeMetaType[15] = dbTypeMetaType[1];
oracleTypeMetaType[0x10] = new MetaType(System.Data.DbType.AnsiString, System.Data.OracleClient.OracleType.RowId, OCI.DATATYPE.VARCHAR2, "ROWID", typeof(string), typeof(OracleString), 0xf6e, 0xf6e, false);
oracleTypeMetaType[0x12] = new MetaType(System.Data.DbType.DateTime, System.Data.OracleClient.OracleType.Timestamp, OCI.DATATYPE.INT_TIMESTAMP, "TIMESTAMP", typeof(DateTime), typeof(OracleDateTime), 11, 11, false);
oracleTypeMetaType[0x13] = new MetaType(System.Data.DbType.DateTime, System.Data.OracleClient.OracleType.TimestampLocal, OCI.DATATYPE.INT_TIMESTAMP_LTZ, "TIMESTAMP WITH LOCAL TIME ZONE", typeof(DateTime), typeof(OracleDateTime), 11, 11, false);
oracleTypeMetaType[20] = new MetaType(System.Data.DbType.DateTime, System.Data.OracleClient.OracleType.TimestampWithTZ, OCI.DATATYPE.INT_TIMESTAMP_TZ, "TIMESTAMP WITH TIME ZONE", typeof(DateTime), typeof(OracleDateTime), 13, 13, false);
oracleTypeMetaType[0x16] = dbTypeMetaType[0];
oracleTypeMetaType[0x17] = dbTypeMetaType[2];
oracleTypeMetaType[0x18] = dbTypeMetaType[0x12];
oracleTypeMetaType[0x19] = dbTypeMetaType[0x13];
oracleTypeMetaType[0x1a] = dbTypeMetaType[14];
oracleTypeMetaType[0x1b] = dbTypeMetaType[10];
oracleTypeMetaType[0x1c] = dbTypeMetaType[11];
oracleTypeMetaType[0x1d] = dbTypeMetaType[15];
oracleTypeMetaType[30] = dbTypeMetaType[8];
oracleTypeMetaType_LONGVARCHAR = new MetaType(System.Data.DbType.AnsiString, System.Data.OracleClient.OracleType.VarChar, OCI.DATATYPE.LONGVARCHAR, "VARCHAR2", typeof(string), typeof(OracleString), 0, 0x7fffffff, false);
oracleTypeMetaType_LONGVARRAW = new MetaType(System.Data.DbType.Binary, System.Data.OracleClient.OracleType.Raw, OCI.DATATYPE.LONGVARRAW, "RAW", typeof(byte[]), typeof(OracleBinary), 0, 0x7fffffff, false);
oracleTypeMetaType_LONGNVARCHAR = new MetaType(System.Data.DbType.String, System.Data.OracleClient.OracleType.NVarChar, OCI.DATATYPE.LONGVARCHAR, "NVARCHAR2", typeof(string), typeof(OracleString), 0, 0x7fffffff, true);
}
private static object CoerceValue(object value, MetaType destinationType)
{
if (((value != null) && !Convert.IsDBNull(value)) && (typeof(object) != destinationType.BaseType))
{
Type type = value.GetType();
if (!(type != destinationType.BaseType) || !(type != destinationType.NoConvertType))
{
return value;
}
try
{
if ((typeof(string) == destinationType.BaseType) && (typeof(char[]) == type))
{
value = new string((char[]) value);
return value;
}
if ((System.Data.DbType.Currency == destinationType.DbType) && (typeof(string) == type))
{
value = decimal.Parse((string) value, NumberStyles.Currency, null);
return value;
}
value = Convert.ChangeType(value, destinationType.BaseType, null);
}
catch (Exception exception)
{
if (!System.Data.Common.ADP.IsCatchableExceptionType(exception))
{
throw;
}
throw System.Data.Common.ADP.ParameterConversionFailed(value, destinationType.BaseType, exception);
}
}
return value;
}
internal void PrepareForBind(OracleConnection connection, ref int offset)
{
OracleParameter parameter = this.Parameter;
bool flag = false;
object obj2 = parameter.Value;
if (!IsDirection(parameter, ParameterDirection.Output) && (obj2 == null))
{
this._bufferLength = 0;
}
else
{
this._bindingMetaType = parameter.GetMetaType(obj2);
if ((OCI.DATATYPE.RSET == this._bindingMetaType.OciType) && System.Data.Common.ADP.IsDirection(parameter.Direction, ParameterDirection.Input))
{
throw System.Data.Common.ADP.InputRefCursorNotSupported(parameter.ParameterName);
}
parameter.SetCoercedValueInternal(obj2, this._bindingMetaType);
this._coercedValue = parameter.GetCoercedValueInternal();
switch (this._bindingMetaType.OciType)
{
case OCI.DATATYPE.CLOB:
case OCI.DATATYPE.BLOB:
case OCI.DATATYPE.BFILE:
if ((!System.Data.Common.ADP.IsNull(this._coercedValue) && !(this._coercedValue is OracleLob)) && !(this._coercedValue is OracleBFile))
{
if (!connection.HasTransaction)
{
this._bindingMetaType = MetaType.GetMetaTypeForType(this._bindingMetaType.DbType);
flag = true;
break;
}
this._freeTemporaryLob = true;
this._coercedValue = this.CreateTemporaryLobForValue(connection, this._bindingMetaType.OracleType, this._coercedValue);
}
break;
}
this._bindSize = this._bindingMetaType.BindSize;
if (((IsDirection(parameter, ParameterDirection.Output) && this._bindingMetaType.IsVariableLength) || ((this._bindSize == 0) && !System.Data.Common.ADP.IsNull(this._coercedValue))) || (this._bindSize > 0x7fff))
{
int bindSize = parameter.BindSize;
if (bindSize != 0)
{
this._bindSize = bindSize;
}
if (((this._bindSize == 0) || (0x7fffffff == this._bindSize)) && !this.IsEmpty(this._coercedValue))
{
throw System.Data.Common.ADP.ParameterSizeIsMissing(parameter.ParameterName, this._bindingMetaType.BaseType);
}
}
this._bufferLength = this._bindSize;
if (this._bindingMetaType.IsCharacterType && connection.ServerVersionAtLeastOracle8)
{
this._bindAsUCS2 = true;
this._bufferLength *= System.Data.Common.ADP.CharSize;
}
if (!System.Data.Common.ADP.IsNull(this._coercedValue) && ((this._bindSize > this._bindingMetaType.MaxBindSize) || flag))
{
switch (this._bindingMetaType.OciType)
{
case OCI.DATATYPE.RAW:
case OCI.DATATYPE.LONGRAW:
this._bindingMetaType = MetaType.oracleTypeMetaType_LONGVARRAW;
break;
case OCI.DATATYPE.CHAR:
case OCI.DATATYPE.VARCHAR2:
case OCI.DATATYPE.LONG:
this._bindingMetaType = this._bindingMetaType.UsesNationalCharacterSet ? MetaType.oracleTypeMetaType_LONGNVARCHAR : MetaType.oracleTypeMetaType_LONGVARCHAR;
break;
}
this._bufferLength += 4;
}
if (0 > this._bufferLength)
{
throw System.Data.Common.ADP.ParameterSizeIsTooLarge(parameter.ParameterName);
}
this._indicatorOffset = offset;
offset += IntPtr.Size;
this._lengthOffset = offset;
offset += IntPtr.Size;
this._valueOffset = offset;
offset += this._bufferLength;
offset = (offset + (IntPtr.Size - 1)) & ~(IntPtr.Size - 1);
}
}
internal void PrepareForBind(OracleConnection connection, ref int offset)
{
OracleParameter parameter = this.Parameter;
bool flag = false;
object obj2 = parameter.Value;
if (!IsDirection(parameter, ParameterDirection.Output) && (obj2 == null))
{
this._bufferLength = 0;
}
else
{
this._bindingMetaType = parameter.GetMetaType(obj2);
if ((OCI.DATATYPE.RSET == this._bindingMetaType.OciType) && System.Data.Common.ADP.IsDirection(parameter.Direction, ParameterDirection.Input))
{
throw System.Data.Common.ADP.InputRefCursorNotSupported(parameter.ParameterName);
}
parameter.SetCoercedValueInternal(obj2, this._bindingMetaType);
this._coercedValue = parameter.GetCoercedValueInternal();
switch (this._bindingMetaType.OciType)
{
case OCI.DATATYPE.CLOB:
case OCI.DATATYPE.BLOB:
case OCI.DATATYPE.BFILE:
if ((!System.Data.Common.ADP.IsNull(this._coercedValue) && !(this._coercedValue is OracleLob)) && !(this._coercedValue is OracleBFile))
{
if (!connection.HasTransaction)
{
this._bindingMetaType = MetaType.GetMetaTypeForType(this._bindingMetaType.DbType);
flag = true;
break;
}
this._freeTemporaryLob = true;
this._coercedValue = this.CreateTemporaryLobForValue(connection, this._bindingMetaType.OracleType, this._coercedValue);
}
break;
}
this._bindSize = this._bindingMetaType.BindSize;
if (((IsDirection(parameter, ParameterDirection.Output) && this._bindingMetaType.IsVariableLength) || ((this._bindSize == 0) && !System.Data.Common.ADP.IsNull(this._coercedValue))) || (this._bindSize > 0x7fff))
{
int bindSize = parameter.BindSize;
if (bindSize != 0)
{
this._bindSize = bindSize;
}
if (((this._bindSize == 0) || (0x7fffffff == this._bindSize)) && !this.IsEmpty(this._coercedValue))
{
throw System.Data.Common.ADP.ParameterSizeIsMissing(parameter.ParameterName, this._bindingMetaType.BaseType);
}
}
this._bufferLength = this._bindSize;
if (this._bindingMetaType.IsCharacterType && connection.ServerVersionAtLeastOracle8)
{
this._bindAsUCS2 = true;
this._bufferLength *= System.Data.Common.ADP.CharSize;
}
if (!System.Data.Common.ADP.IsNull(this._coercedValue) && ((this._bindSize > this._bindingMetaType.MaxBindSize) || flag))
{
switch (this._bindingMetaType.OciType)
{
case OCI.DATATYPE.RAW:
case OCI.DATATYPE.LONGRAW:
this._bindingMetaType = MetaType.oracleTypeMetaType_LONGVARRAW;
break;
case OCI.DATATYPE.CHAR:
case OCI.DATATYPE.VARCHAR2:
case OCI.DATATYPE.LONG:
this._bindingMetaType = this._bindingMetaType.UsesNationalCharacterSet ? MetaType.oracleTypeMetaType_LONGNVARCHAR : MetaType.oracleTypeMetaType_LONGVARCHAR;
break;
}
this._bufferLength += 4;
}
if (0 > this._bufferLength)
{
throw System.Data.Common.ADP.ParameterSizeIsTooLarge(parameter.ParameterName);
}
this._indicatorOffset = offset;
offset += IntPtr.Size;
this._lengthOffset = offset;
offset += IntPtr.Size;
this._valueOffset = offset;
offset += this._bufferLength;
offset = (offset + (IntPtr.Size - 1)) & ~(IntPtr.Size - 1);
}
}
internal static string MarshalToString(NativeBuffer buffer, int valueOffset, int lengthOffset, MetaType metaType, OracleConnection connection, bool boundAsUCS2, bool outputParameterBinding)
{
string str;
int length = GetLength(buffer, lengthOffset, metaType);
if (boundAsUCS2 && outputParameterBinding)
{
length /= 2;
}
bool flag = metaType.IsLong && !outputParameterBinding;
if (boundAsUCS2)
{
if (flag)
{
byte[] destinationBuffer = new byte[length * System.Data.Common.ADP.CharSize];
NativeBuffer_LongColumnData.CopyOutOfLineBytes(buffer.ReadIntPtr(valueOffset), 0, destinationBuffer, 0, length * System.Data.Common.ADP.CharSize);
str = Encoding.Unicode.GetString(destinationBuffer);
}
else
{
str = buffer.PtrToStringUni(valueOffset, length);
}
}
else
{
byte[] buffer2;
if (flag)
{
buffer2 = new byte[length];
NativeBuffer_LongColumnData.CopyOutOfLineBytes(buffer.ReadIntPtr(valueOffset), 0, buffer2, 0, length);
}
else
{
buffer2 = buffer.ReadBytes(valueOffset, length);
}
str = connection.GetString(buffer2, metaType.UsesNationalCharacterSet);
}
GC.KeepAlive(buffer);
return str;
}
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 GetLength(NativeBuffer buffer, int lengthOffset, MetaType metaType)
{
if (metaType.IsLong)
{
return buffer.ReadInt32(lengthOffset);
}
return buffer.ReadInt16(lengthOffset);
}
internal void SetCoercedValueInternal(object value, MetaType metaType)
{
this._coercedMetaType = metaType;
this.CoercedValue = CoerceValue(value, metaType);
}
internal static byte[] GetBytesFromDescriptor(OciDateTimeDescriptor dateTimeDescriptor, MetaType metaType, OracleConnection connection)
{
uint num2;
OCI.DATATYPE ociType = metaType.OciType;
OCI.DATATYPE datatype2 = ociType;
if (datatype2 == OCI.DATATYPE.INT_TIMESTAMP)
{
num2 = 11;
}
else if (datatype2 == OCI.DATATYPE.INT_TIMESTAMP_LTZ)
{
num2 = 13;
}
else
{
num2 = 13;
}
byte[] outarray = new byte[num2];
uint len = num2;
OciIntervalDescriptor reftz = new OciIntervalDescriptor(connection.EnvironmentHandle);
int rc = System.Data.Common.UnsafeNativeMethods.OCIDateTimeToArray(connection.EnvironmentHandle, connection.ErrorHandle, dateTimeDescriptor, reftz, outarray, ref len, 9);
if (rc != 0)
{
connection.CheckError(connection.ErrorHandle, rc);
}
if (OCI.DATATYPE.INT_TIMESTAMP_LTZ == ociType)
{
TimeSpan serverTimeZoneAdjustmentToUTC = connection.ServerTimeZoneAdjustmentToUTC;
outarray[11] = (byte) (serverTimeZoneAdjustmentToUTC.Hours + 20);
outarray[12] = (byte) (serverTimeZoneAdjustmentToUTC.Minutes + 60);
return outarray;
}
if (OCI.DATATYPE.INT_TIMESTAMP_TZ == ociType)
{
sbyte num3;
sbyte num4;
rc = System.Data.Common.UnsafeNativeMethods.OCIDateTimeGetTimeZoneOffset(connection.EnvironmentHandle, connection.ErrorHandle, dateTimeDescriptor, out num4, out num3);
if (rc != 0)
{
connection.CheckError(connection.ErrorHandle, rc);
}
outarray[11] = (byte) (num4 + 20);
outarray[12] = (byte) (num3 + 60);
}
return outarray;
}
internal OracleString(NativeBuffer buffer, int valueOffset, int lengthOffset, MetaType metaType, OracleConnection connection, bool boundAsUCS2, bool outputParameterBinding)
{
this._value = MarshalToString(buffer, valueOffset, lengthOffset, metaType, connection, boundAsUCS2, outputParameterBinding);
}
internal static string MarshalToString(NativeBuffer buffer, int valueOffset, int lengthOffset, MetaType metaType, OracleConnection connection, bool boundAsUCS2, bool outputParameterBinding)
{
string str;
int length = GetLength(buffer, lengthOffset, metaType);
if (boundAsUCS2 && outputParameterBinding)
{
length /= 2;
}
bool flag = metaType.IsLong && !outputParameterBinding;
if (boundAsUCS2)
{
if (flag)
{
byte[] destinationBuffer = new byte[length * System.Data.Common.ADP.CharSize];
NativeBuffer_LongColumnData.CopyOutOfLineBytes(buffer.ReadIntPtr(valueOffset), 0, destinationBuffer, 0, length * System.Data.Common.ADP.CharSize);
str = Encoding.Unicode.GetString(destinationBuffer);
}
else
{
str = buffer.PtrToStringUni(valueOffset, length);
}
}
else
{
byte[] buffer2;
if (flag)
{
buffer2 = new byte[length];
NativeBuffer_LongColumnData.CopyOutOfLineBytes(buffer.ReadIntPtr(valueOffset), 0, buffer2, 0, length);
}
else
{
buffer2 = buffer.ReadBytes(valueOffset, length);
}
str = connection.GetString(buffer2, metaType.UsesNationalCharacterSet);
}
GC.KeepAlive(buffer);
return(str);
}
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 OracleString GetPersistedRowid(OracleConnection connection, OciRowidDescriptor rowidHandle)
{
OracleString @null = OracleString.Null;
if (rowidHandle != null)
{
OciErrorHandle errorHandle = connection.ErrorHandle;
NativeBuffer scratchBuffer = connection.GetScratchBuffer(0xf82);
bool success = false;
bool flag = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
int num;
scratchBuffer.DangerousAddRef(ref success);
if (OCI.ClientVersionAtLeastOracle9i)
{
int length = scratchBuffer.Length;
num = TracedNativeMethods.OCIRowidToChar(rowidHandle, scratchBuffer, ref length, errorHandle);
if (num != 0)
{
connection.CheckError(errorHandle, num);
}
return(new OracleString(scratchBuffer.PtrToStringAnsi(0, length)));
}
rowidHandle.DangerousAddRef(ref flag);
OciServiceContextHandle serviceContextHandle = connection.ServiceContextHandle;
OciStatementHandle stmtp = new OciStatementHandle(serviceContextHandle);
string stmt = "begin :rowid := :rdesc; end;";
int offset = 0;
int num6 = 4;
int num5 = 8;
int num3 = 12;
int num2 = 0x10;
int num4 = 20;
try
{
IntPtr ptr;
IntPtr ptr2;
num = TracedNativeMethods.OCIStmtPrepare(stmtp, errorHandle, stmt, OCI.SYNTAX.OCI_NTV_SYNTAX, OCI.MODE.OCI_DEFAULT, connection);
if (num != 0)
{
connection.CheckError(errorHandle, num);
}
scratchBuffer.WriteIntPtr(num5, rowidHandle.DangerousGetHandle());
scratchBuffer.WriteInt32(offset, 0);
scratchBuffer.WriteInt32(num6, 4);
scratchBuffer.WriteInt32(num3, 0);
scratchBuffer.WriteInt32(num2, 0xf6e);
num = TracedNativeMethods.OCIBindByName(stmtp, out ptr2, errorHandle, "rowid", 5, scratchBuffer.DangerousGetDataPtr(num4), 0xf6e, OCI.DATATYPE.VARCHAR2, scratchBuffer.DangerousGetDataPtr(num3), scratchBuffer.DangerousGetDataPtr(num2), OCI.MODE.OCI_DEFAULT);
if (num != 0)
{
connection.CheckError(errorHandle, num);
}
num = TracedNativeMethods.OCIBindByName(stmtp, out ptr, errorHandle, "rdesc", 5, scratchBuffer.DangerousGetDataPtr(num5), 4, OCI.DATATYPE.ROWID_DESC, scratchBuffer.DangerousGetDataPtr(offset), scratchBuffer.DangerousGetDataPtr(num6), OCI.MODE.OCI_DEFAULT);
if (num != 0)
{
connection.CheckError(errorHandle, num);
}
num = TracedNativeMethods.OCIStmtExecute(serviceContextHandle, stmtp, errorHandle, 1, OCI.MODE.OCI_DEFAULT);
if (num != 0)
{
connection.CheckError(errorHandle, num);
}
if (scratchBuffer.ReadInt16(num3) == -1)
{
return(@null);
}
@null = new OracleString(scratchBuffer, num4, num2, MetaType.GetMetaTypeForType(OracleType.RowId), connection, false, true);
GC.KeepAlive(rowidHandle);
}
finally
{
OciHandle.SafeDispose(ref stmtp);
}
}
finally
{
if (flag)
{
rowidHandle.DangerousRelease();
}
if (success)
{
scratchBuffer.DangerousRelease();
}
}
}
return(@null);
}
internal int PutOracleValue(object value, NativeBuffer buffer, int bufferOffset, MetaType metaType, OracleConnection connection, ref SafeHandle handleToBind)
{
handleToBind = null;
OCI.DATATYPE ociType = metaType.OciType;
OracleParameter parameter = this.Parameter;
switch (ociType)
{
case OCI.DATATYPE.VARCHAR2:
case OCI.DATATYPE.LONG:
case OCI.DATATYPE.LONGVARCHAR:
case OCI.DATATYPE.CHAR:
return(OracleString.MarshalToNative(value, parameter.Offset, parameter.GetActualSize(), buffer, bufferOffset, ociType, this._bindAsUCS2));
case OCI.DATATYPE.INTEGER:
case OCI.DATATYPE.FLOAT:
case OCI.DATATYPE.UNSIGNEDINT:
buffer.StructureToPtr(bufferOffset, value);
return(metaType.BindSize);
case OCI.DATATYPE.VARNUM:
return(OracleNumber.MarshalToNative(value, buffer, bufferOffset, connection));
case OCI.DATATYPE.DATE:
return(OracleDateTime.MarshalDateToNative(value, buffer, bufferOffset, ociType, connection));
case OCI.DATATYPE.RAW:
case OCI.DATATYPE.LONGRAW:
case OCI.DATATYPE.LONGVARRAW:
{
int num;
byte[] buffer2;
if (this._coercedValue is OracleBinary)
{
OracleBinary binary = (OracleBinary)this._coercedValue;
buffer2 = binary.Value;
}
else
{
buffer2 = (byte[])this._coercedValue;
}
int num2 = buffer2.Length - parameter.Offset;
int actualSize = parameter.GetActualSize();
if (actualSize != 0)
{
num2 = Math.Min(num2, actualSize);
}
if (OCI.DATATYPE.LONGVARRAW == ociType)
{
buffer.WriteInt32(bufferOffset, num2);
bufferOffset += 4;
num = num2 + 4;
}
else
{
num = num2;
}
buffer.WriteBytes(bufferOffset, buffer2, parameter.Offset, num2);
return(num);
}
case OCI.DATATYPE.CLOB:
case OCI.DATATYPE.BLOB:
if (!(value is OracleLob))
{
throw System.Data.Common.ADP.BadBindValueType(value.GetType(), metaType.OracleType);
}
handleToBind = ((OracleLob)value).Descriptor;
return(IntPtr.Size);
case OCI.DATATYPE.BFILE:
if (!(value is OracleBFile))
{
throw System.Data.Common.ADP.BadBindValueType(value.GetType(), metaType.OracleType);
}
handleToBind = ((OracleBFile)value).Descriptor;
return(IntPtr.Size);
case OCI.DATATYPE.INT_TIMESTAMP:
case OCI.DATATYPE.INT_TIMESTAMP_LTZ:
if (value is OracleDateTime)
{
OracleDateTime time = (OracleDateTime)value;
if (!time.HasTimeInfo)
{
throw System.Data.Common.ADP.UnsupportedOracleDateTimeBinding(metaType.OracleType);
}
}
this._dateTimeDescriptor = OracleDateTime.CreateDescriptor(ociType, connection, value);
handleToBind = this._dateTimeDescriptor;
return(IntPtr.Size);
case OCI.DATATYPE.INT_TIMESTAMP_TZ:
if (value is OracleDateTime)
{
OracleDateTime time2 = (OracleDateTime)value;
if (!time2.HasTimeZoneInfo)
{
throw System.Data.Common.ADP.UnsupportedOracleDateTimeBinding(OracleType.TimestampWithTZ);
}
}
this._dateTimeDescriptor = OracleDateTime.CreateDescriptor(ociType, connection, value);
handleToBind = this._dateTimeDescriptor;
return(IntPtr.Size);
case OCI.DATATYPE.INT_INTERVAL_YM:
return(OracleMonthSpan.MarshalToNative(value, buffer, bufferOffset));
case OCI.DATATYPE.INT_INTERVAL_DS:
return(OracleTimeSpan.MarshalToNative(value, buffer, bufferOffset));
}
throw System.Data.Common.ADP.TypeNotSupported(ociType);
}
internal MetaType GetMetaType(object value)
{
MetaType metaTypeForObject = this._metaType;
if (metaTypeForObject == null)
{
if ((value != null) && !Convert.IsDBNull(value))
{
metaTypeForObject = MetaType.GetMetaTypeForObject(value);
}
else
{
metaTypeForObject = MetaType.GetDefaultMetaType();
}
this._metaType = metaTypeForObject;
}
return metaTypeForObject;
}
public void ResetOracleType()
{
if (this._metaType != null)
{
this.PropertyTypeChanging();
this._metaType = null;
}
}
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;
}
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 DateTime MarshalToDateTime(NativeBuffer buffer, int valueOffset, int lengthOffset, MetaType metaType, OracleConnection connection)
{
return ToDateTime(GetBytesFromBuffer(buffer, valueOffset, lengthOffset, metaType, connection));
}
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 static DateTime MarshalTimestampToDateTime(OciDateTimeDescriptor dateTimeDescriptor, MetaType metaType, OracleConnection connection)
{
return ToDateTime(GetBytesFromDescriptor(dateTimeDescriptor, metaType, connection));
}
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 OracleDateTime(NativeBuffer buffer, int valueOffset, int lengthOffset, MetaType metaType, OracleConnection connection)
{
this._value = GetBytesFromBuffer(buffer, valueOffset, lengthOffset, metaType, connection);
}
internal OracleString(NativeBuffer buffer, int valueOffset, int lengthOffset, MetaType metaType, OracleConnection connection, bool boundAsUCS2, bool outputParameterBinding)
{
this._value = MarshalToString(buffer, valueOffset, lengthOffset, metaType, connection, boundAsUCS2, outputParameterBinding);
}
internal OracleDateTime(OciDateTimeDescriptor dateTimeDescriptor, MetaType metaType, OracleConnection connection)
{
this._value = GetBytesFromDescriptor(dateTimeDescriptor, metaType, connection);
}
internal int PutOracleValue(object value, NativeBuffer buffer, int bufferOffset, MetaType metaType, OracleConnection connection, ref SafeHandle handleToBind)
{
handleToBind = null;
OCI.DATATYPE ociType = metaType.OciType;
OracleParameter parameter = this.Parameter;
switch (ociType)
{
case OCI.DATATYPE.VARCHAR2:
case OCI.DATATYPE.LONG:
case OCI.DATATYPE.LONGVARCHAR:
case OCI.DATATYPE.CHAR:
return OracleString.MarshalToNative(value, parameter.Offset, parameter.GetActualSize(), buffer, bufferOffset, ociType, this._bindAsUCS2);
case OCI.DATATYPE.INTEGER:
case OCI.DATATYPE.FLOAT:
case OCI.DATATYPE.UNSIGNEDINT:
buffer.StructureToPtr(bufferOffset, value);
return metaType.BindSize;
case OCI.DATATYPE.VARNUM:
return OracleNumber.MarshalToNative(value, buffer, bufferOffset, connection);
case OCI.DATATYPE.DATE:
return OracleDateTime.MarshalDateToNative(value, buffer, bufferOffset, ociType, connection);
case OCI.DATATYPE.RAW:
case OCI.DATATYPE.LONGRAW:
case OCI.DATATYPE.LONGVARRAW:
{
int num;
byte[] buffer2;
if (this._coercedValue is OracleBinary)
{
OracleBinary binary = (OracleBinary) this._coercedValue;
buffer2 = binary.Value;
}
else
{
buffer2 = (byte[]) this._coercedValue;
}
int num2 = buffer2.Length - parameter.Offset;
int actualSize = parameter.GetActualSize();
if (actualSize != 0)
{
num2 = Math.Min(num2, actualSize);
}
if (OCI.DATATYPE.LONGVARRAW == ociType)
{
buffer.WriteInt32(bufferOffset, num2);
bufferOffset += 4;
num = num2 + 4;
}
else
{
num = num2;
}
buffer.WriteBytes(bufferOffset, buffer2, parameter.Offset, num2);
return num;
}
case OCI.DATATYPE.CLOB:
case OCI.DATATYPE.BLOB:
if (!(value is OracleLob))
{
throw System.Data.Common.ADP.BadBindValueType(value.GetType(), metaType.OracleType);
}
handleToBind = ((OracleLob) value).Descriptor;
return IntPtr.Size;
case OCI.DATATYPE.BFILE:
if (!(value is OracleBFile))
{
throw System.Data.Common.ADP.BadBindValueType(value.GetType(), metaType.OracleType);
}
handleToBind = ((OracleBFile) value).Descriptor;
return IntPtr.Size;
case OCI.DATATYPE.INT_TIMESTAMP:
case OCI.DATATYPE.INT_TIMESTAMP_LTZ:
if (value is OracleDateTime)
{
OracleDateTime time = (OracleDateTime) value;
if (!time.HasTimeInfo)
{
throw System.Data.Common.ADP.UnsupportedOracleDateTimeBinding(metaType.OracleType);
}
}
this._dateTimeDescriptor = OracleDateTime.CreateDescriptor(ociType, connection, value);
handleToBind = this._dateTimeDescriptor;
return IntPtr.Size;
case OCI.DATATYPE.INT_TIMESTAMP_TZ:
if (value is OracleDateTime)
{
OracleDateTime time2 = (OracleDateTime) value;
if (!time2.HasTimeZoneInfo)
{
throw System.Data.Common.ADP.UnsupportedOracleDateTimeBinding(OracleType.TimestampWithTZ);
}
}
this._dateTimeDescriptor = OracleDateTime.CreateDescriptor(ociType, connection, value);
handleToBind = this._dateTimeDescriptor;
return IntPtr.Size;
case OCI.DATATYPE.INT_INTERVAL_YM:
return OracleMonthSpan.MarshalToNative(value, buffer, bufferOffset);
case OCI.DATATYPE.INT_INTERVAL_DS:
return OracleTimeSpan.MarshalToNative(value, buffer, bufferOffset);
}
throw System.Data.Common.ADP.TypeNotSupported(ociType);
}
internal bool Describe(ref int offset, OracleConnection connection, OciErrorHandle errorHandle)
{
byte num;
short num3;
bool flag = false;
bool flag2 = false;
this._describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_SQLCODE, out this._columnName, errorHandle, this._connection);
this._describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_OBJECT, out num3, errorHandle);
this._describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_SESSION, out num, errorHandle);
this._isNullable = 0 != num;
OCI.DATATYPE ociType = (OCI.DATATYPE)num3;
switch (ociType)
{
case OCI.DATATYPE.VARCHAR2:
case OCI.DATATYPE.CHAR:
{
int num2;
this._describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_FNCODE, out this._byteSize, errorHandle);
this._describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_CHARSET_FORM, out num, errorHandle);
OCI.CHARSETFORM charsetform = (OCI.CHARSETFORM)num;
this._bindAsUTF16 = connection.ServerVersionAtLeastOracle8;
if (connection.ServerVersionAtLeastOracle9i && OCI.ClientVersionAtLeastOracle9i)
{
this._describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_CHAR_SIZE, out num3, errorHandle);
num2 = num3;
}
else
{
num2 = this._byteSize;
}
if (charsetform == OCI.CHARSETFORM.SQLCS_NCHAR)
{
this._metaType = MetaType.GetMetaTypeForType((OCI.DATATYPE.CHAR == ociType) ? System.Data.OracleClient.OracleType.NChar : System.Data.OracleClient.OracleType.NVarChar);
}
else
{
this._metaType = MetaType.GetMetaTypeForType((OCI.DATATYPE.CHAR == ociType) ? System.Data.OracleClient.OracleType.Char : System.Data.OracleClient.OracleType.VarChar);
if (this._bindAsUTF16)
{
this._byteSize *= System.Data.Common.ADP.CharSize;
}
}
this._byteSize = Math.Max(this._byteSize, num2 * System.Data.Common.ADP.CharSize);
flag = true;
break;
}
case OCI.DATATYPE.NUMBER:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.Number);
this._byteSize = this._metaType.BindSize;
this._describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_ENV, out this._precision, errorHandle);
this._describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_SERVER, out this._scale, errorHandle);
break;
case OCI.DATATYPE.LONG:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.LongVarChar);
this._byteSize = this._metaType.BindSize;
flag = true;
flag2 = true;
this._bindAsUTF16 = connection.ServerVersionAtLeastOracle8;
break;
case OCI.DATATYPE.ROWID:
case OCI.DATATYPE.ROWID_DESC:
case OCI.DATATYPE.UROWID:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.RowId);
this._byteSize = this._metaType.BindSize;
if (connection.UnicodeEnabled)
{
this._bindAsUTF16 = true;
this._byteSize *= System.Data.Common.ADP.CharSize;
}
flag = true;
break;
case OCI.DATATYPE.DATE:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.DateTime);
this._byteSize = this._metaType.BindSize;
flag = true;
break;
case OCI.DATATYPE.RAW:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.Raw);
this._describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_FNCODE, out this._byteSize, errorHandle);
flag = true;
break;
case OCI.DATATYPE.LONGRAW:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.LongRaw);
this._byteSize = this._metaType.BindSize;
flag = true;
flag2 = true;
break;
case OCI.DATATYPE.CLOB:
this._describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_CHARSET_FORM, out num, errorHandle);
this._metaType = MetaType.GetMetaTypeForType((2 == num) ? System.Data.OracleClient.OracleType.NClob : System.Data.OracleClient.OracleType.Clob);
this._byteSize = this._metaType.BindSize;
flag2 = true;
break;
case OCI.DATATYPE.BLOB:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.Blob);
this._byteSize = this._metaType.BindSize;
flag2 = true;
break;
case OCI.DATATYPE.BFILE:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.BFile);
this._byteSize = this._metaType.BindSize;
flag2 = true;
break;
case OCI.DATATYPE.TIMESTAMP:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.Timestamp);
this._byteSize = this._metaType.BindSize;
flag = true;
break;
case OCI.DATATYPE.TIMESTAMP_TZ:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.TimestampWithTZ);
this._byteSize = this._metaType.BindSize;
flag = true;
break;
case OCI.DATATYPE.INTERVAL_YM:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.IntervalYearToMonth);
this._byteSize = this._metaType.BindSize;
break;
case OCI.DATATYPE.INTERVAL_DS:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.IntervalDayToSecond);
this._byteSize = this._metaType.BindSize;
break;
case OCI.DATATYPE.TIMESTAMP_LTZ:
this._metaType = MetaType.GetMetaTypeForType(System.Data.OracleClient.OracleType.TimestampLocal);
this._byteSize = this._metaType.BindSize;
flag = true;
break;
default:
throw System.Data.Common.ADP.TypeNotSupported(ociType);
}
if (this._isNullable)
{
this._indicatorOffset = offset;
offset += IntPtr.Size;
}
else
{
this._indicatorOffset = -1;
}
if (flag)
{
this._lengthOffset = offset;
offset += IntPtr.Size;
}
else
{
this._lengthOffset = -1;
}
this._valueOffset = offset;
if ((OCI.DATATYPE.LONG == ociType) || (OCI.DATATYPE.LONGRAW == ociType))
{
offset += IntPtr.Size;
}
else
{
offset += this._byteSize;
}
offset = (offset + (IntPtr.Size - 1)) & ~(IntPtr.Size - 1);
OciHandle.SafeDispose(ref this._describeHandle);
return(flag2);
}
