Files
mono/mcs/class/System.Data.OracleClient/System.Data.OracleClient.Oci/OciDefineHandle.cs
T
Neale Ferguson 3f740f3d94 Fixes 19752 -
Users have been complaining about strange errors arising when using the OracleClient classes.
I have tracked it down to the OciDefineHandle and OciDefineByPos calls, and OracleParameter
handling of amanged objects by unmanaged code. Currently two of the parameters passed to the
above OCI  call are short variables. They are passed as "ref" fields as Oracle uses their
address to put size and indicator data once the data is fetched. However, being defined as
short means that they are eligible for being moved during garbage collection. Thus if that
field is moved between the OciDefineByPos call and the fetch of the data then what Oracle is
pointing to may no longer be variable. I'm thinking it may be better to define these fields as
IntPtr and allocate them and retrieve their values via Marshal.ReadInt16. As for OracleParameter,
it uses a managed object "indicator" that is also used in a similar way. This reference is replaced
by a IntPtr and a get/set method to access the contents.
2014-09-12 11:25:57 -04:00

674 lines
17 KiB
C#

//
// OciDefineHandle.cs
//
// Part of managed C#/.NET library System.Data.OracleClient.dll
//
// Part of the Mono class libraries at
// mcs/class/System.Data.OracleClient/System.Data.OracleClient.Oci
//
// Assembly: System.Data.OracleClient.dll
// Namespace: System.Data.OracleClient.Oci
//
// Authors:
// Tim Coleman <[email protected]>
// Daniel Morgan <[email protected]>
//
// Copyright (C) Tim Coleman, 2003
// Copyright (C) Daniel Morgan, 2004, 2009
//
using System;
using System.Data.OracleClient;
using System.Runtime.InteropServices;
using System.Text;
namespace System.Data.OracleClient.Oci
{
internal sealed class OciDefineHandle : OciHandle, IDisposable
{
#region Fields
bool disposed = false;
//IntPtr handle;
IntPtr value;
IntPtr indicator;
//OracleType type;
OciDataType ociType;
OciDataType definedType;
int definedSize;
IntPtr rlenp;
//short precision;
short scale;
Type fieldType;
string name;
// Oracle defines the LONG VARCHAR and LONG VARRAW to have a size of 2 to the 31 power - 5
// see DefineLongVarChar and DefineLongVarRaw
// TODO: see OCI Programmers Guide on how to do a piece-wise operations
// instead of using the below. Or better yet, convert
// your LONG/LONG VARCHAR to CLOB and LONG RAW/LONG VARRAW to BLOB.
internal static int LongVarCharMaxValue = (int) Int16.MaxValue - 5;
internal static int LongVarRawMaxValue = (int) Int16.MaxValue - 5;
OciErrorHandle errorHandle;
OciLobLocator lobLocator;
OciDateTimeDescriptor dateTimeDesc;
OciIntervalDescriptor intervalDesc;
#endregion // Fields
#region Constructors
internal OciDefineHandle (OciHandle parent, IntPtr newHandle)
: base (OciHandleType.Define, parent, newHandle)
{
}
internal void DefineByPosition (int position, OracleConnection connection)
{
OciParameterDescriptor parameter = ((OciStatementHandle) Parent).GetParameter (position);
name = parameter.GetName ();
definedType = parameter.GetDataType ();
definedSize = parameter.GetDataSize ();
//precision = parameter.GetPrecision ();
scale = parameter.GetScale ();
rlenp = OciCalls.AllocateClear (sizeof(short));
indicator = OciCalls.AllocateClear (sizeof(short));
Define (position, connection);
parameter.Dispose ();
}
#endregion // Constructors
#region Properties
internal OciDataType DataType {
get { return definedType; }
}
internal Type FieldType {
get { return fieldType; }
}
internal int DefinedSize {
get { return definedSize; }
}
internal OciErrorHandle ErrorHandle {
get { return errorHandle; }
set { errorHandle = value; }
}
internal bool IsNull {
get { return (Indicator == -1); }
}
internal short Scale {
get { return scale; }
}
internal short Size {
get { return(Marshal.ReadInt16(rlenp)); }
set { Marshal.WriteInt16(rlenp, value); }
}
internal short Indicator {
get { return(Marshal.ReadInt16(indicator)); }
set { Marshal.WriteInt16(indicator, value); }
}
internal IntPtr Value {
get { return value; }
}
#endregion
#region Methods
void Define (int position, OracleConnection connection)
{
switch (definedType) {
case OciDataType.Date:
DefineDate (position, connection);
return;
case OciDataType.TimeStamp:
DefineTimeStamp (position, connection);
return;
case OciDataType.Clob:
case OciDataType.Blob:
DefineLob (position, definedType, connection);
return;
case OciDataType.Raw:
case OciDataType.VarRaw:
DefineRaw( position, connection);
return;
case OciDataType.LongRaw:
case OciDataType.LongVarRaw:
DefineLongVarRaw (position, connection);
return;
case OciDataType.RowIdDescriptor:
definedSize = 10;
DefineChar (position, connection);
return;
case OciDataType.Integer:
case OciDataType.Number:
case OciDataType.Float:
case OciDataType.VarNum:
case OciDataType.UnsignedInt:
DefineNumber (position, connection);
return;
case OciDataType.Long:
case OciDataType.LongVarChar:
DefineLongVarChar (position, connection);
return;
case OciDataType.IntervalDayToSecond:
case OciDataType.IntervalYearToMonth:
DefineInterval (position, definedType, connection);
return;
default:
DefineChar (position, connection); // HANDLE ALL OTHERS AS CHAR FOR NOW
return;
}
}
void DefineTimeStamp (int position, OracleConnection connection)
{
definedSize = -1;
ociType = OciDataType.TimeStamp;
fieldType = typeof(System.DateTime);
dateTimeDesc = (OciDateTimeDescriptor) connection.Environment.Allocate (OciHandleType.TimeStamp);
if (dateTimeDesc == null) {
OciErrorInfo info = connection.ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
value = dateTimeDesc.Handle;
dateTimeDesc.ErrorHandle = ErrorHandle;
int status = 0;
status = OciCalls.OCIDefineByPosPtr (Parent,
out handle,
ErrorHandle,
position + 1,
ref value,
definedSize,
ociType,
indicator,
rlenp,
IntPtr.Zero,
0);
definedSize = 11;
if (status != 0) {
OciErrorInfo info = connection.ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
}
void DefineDate (int position, OracleConnection connection)
{
definedSize = 7;
ociType = OciDataType.Date;
fieldType = typeof(System.DateTime);
value = OciCalls.AllocateClear (definedSize);
int status = 0;
status = OciCalls.OCIDefineByPos (Parent,
out handle,
ErrorHandle,
position + 1,
value,
definedSize,
ociType,
indicator,
rlenp,
IntPtr.Zero,
0);
if (status != 0) {
OciErrorInfo info = ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
}
void DefineLongVarChar (int position, OracleConnection connection)
{
fieldType = typeof (System.String);
// LONG VARCHAR max length is 2 to the 31 power - 5
// the first 4 bytes of a LONG VARCHAR value contains the length
// Int32.MaxValue - 5 causes out of memory in mono on win32
// because I do not have 2GB of memory available
// so Int16.MaxValue - 5 is used instead.
// LAMESPEC for Oracle OCI - you can not get the length of the LONG VARCHAR value
// until after you get the value. This could be why Oracle deprecated LONG VARCHAR.
// If you specify a definedSize less then the length of the column value,
// then you will get an OCI_ERROR ORA-01406: fetched column value was truncated
// TODO: get via piece-wise - a chunk at a time
definedSize = LongVarCharMaxValue;
value = OciCalls.AllocateClear (definedSize);
ociType = OciDataType.LongVarChar;
int status = 0;
status = OciCalls.OCIDefineByPos (Parent,
out handle,
ErrorHandle,
position + 1,
value,
definedSize,
ociType,
indicator,
rlenp,
IntPtr.Zero, 0);
Size = (short) definedSize;
if (status != 0) {
OciErrorInfo info = ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
}
void DefineChar (int position, OracleConnection connection)
{
fieldType = typeof (System.String);
int maxByteCount = Encoding.UTF8.GetMaxByteCount (definedSize);
value = OciCalls.AllocateClear (maxByteCount);
ociType = OciDataType.Char;
int status = 0;
status = OciCalls.OCIDefineByPos (Parent,
out handle,
ErrorHandle,
position + 1,
value,
maxByteCount,
ociType,
indicator,
rlenp,
IntPtr.Zero,
0);
OciErrorHandle.ThrowExceptionIfError (ErrorHandle, status);
}
void DefineNumber (int position, OracleConnection connection)
{
fieldType = typeof (System.Decimal);
value = OciCalls.AllocateClear (definedSize);
ociType = OciDataType.Char;
int status = 0;
status = OciCalls.OCIDefineByPos (Parent,
out handle,
ErrorHandle,
position + 1,
value,
definedSize,
ociType,
indicator,
rlenp,
IntPtr.Zero,
0);
if (status != 0) {
OciErrorInfo info = ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
}
void DefineLob (int position, OciDataType type, OracleConnection connection)
{
ociType = type;
if (ociType == OciDataType.Clob)
fieldType = typeof(System.String);
else if (ociType == OciDataType.Blob)
fieldType = typeof(byte[]);
int status = 0;
definedSize = -1;
lobLocator = (OciLobLocator) connection.Environment.Allocate (OciHandleType.LobLocator);
if (lobLocator == null) {
OciErrorInfo info = connection.ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
value = lobLocator.Handle;
lobLocator.ErrorHandle = connection.ErrorHandle;
lobLocator.Service = connection.ServiceContext;
lobLocator.Environment = connection.Environment;
status = OciCalls.OCIDefineByPosPtr (Parent,
out handle,
ErrorHandle,
position + 1,
ref value,
definedSize,
ociType,
indicator,
rlenp,
IntPtr.Zero,
0);
definedSize = Int32.MaxValue;
if (status != 0) {
OciErrorInfo info = connection.ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
}
void DefineRaw (int position, OracleConnection connection)
{
ociType = OciDataType.Raw;
fieldType = typeof (byte[]);
value = OciCalls.AllocateClear (definedSize);
int status = 0;
status = OciCalls.OCIDefineByPos (Parent,
out handle,
ErrorHandle,
position + 1,
value,
definedSize,
ociType,
indicator,
rlenp,
IntPtr.Zero, 0);
if (status != 0) {
OciErrorInfo info = ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
}
void DefineLongVarRaw (int position, OracleConnection connection)
{
ociType = OciDataType.LongVarRaw;
fieldType = typeof (byte[]);
// TODO: get via piece-wise - a chunk at a time
definedSize = LongVarRawMaxValue;
value = OciCalls.AllocateClear (definedSize);
int status = 0;
status = OciCalls.OCIDefineByPos (Parent,
out handle,
ErrorHandle,
position + 1,
value,
definedSize,
ociType,
indicator,
rlenp,
IntPtr.Zero, 0);
if (status != 0) {
OciErrorInfo info = ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
}
void DefineInterval (int position, OciDataType type, OracleConnection connection)
{
ociType = type;
fieldType = typeof(string);
definedSize = -1;
switch (type) {
case OciDataType.IntervalDayToSecond:
definedSize = 11;
intervalDesc = (OciIntervalDescriptor) connection.Environment.Allocate (OciHandleType.IntervalDayToSecond);
break;
case OciDataType.IntervalYearToMonth:
intervalDesc = (OciIntervalDescriptor) connection.Environment.Allocate (OciHandleType.IntervalYearToMonth);
definedSize = 5;
break;
}
if (intervalDesc == null) {
OciErrorInfo info = connection.ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
value = intervalDesc.Handle;
intervalDesc.ErrorHandle = ErrorHandle;
int status = 0;
status = OciCalls.OCIDefineByPosPtr (Parent,
out handle,
ErrorHandle,
position + 1,
ref value,
definedSize,
ociType,
indicator,
rlenp,
IntPtr.Zero,
0);
if (status != 0) {
OciErrorInfo info = connection.ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
}
protected override void Dispose (bool disposing)
{
if (!disposed) {
try {
switch (definedType) {
case OciDataType.Clob:
case OciDataType.Blob:
case OciDataType.TimeStamp:
case OciDataType.IntervalDayToSecond:
case OciDataType.IntervalYearToMonth:
break;
default:
Marshal.FreeHGlobal (value);
break;
}
disposed = true;
} finally {
Marshal.FreeHGlobal (indicator);
Marshal.FreeHGlobal (rlenp);
base.Dispose (disposing);
value = IntPtr.Zero;
}
}
}
internal OracleLob GetOracleLob ()
{
return new OracleLob (lobLocator, ociType);
}
internal object GetValue (IFormatProvider formatProvider, OracleConnection conn)
{
object tmp;
byte [] buffer = null;
switch (DataType) {
case OciDataType.VarChar2:
case OciDataType.String:
case OciDataType.VarChar:
case OciDataType.Char:
case OciDataType.CharZ:
case OciDataType.OciString:
case OciDataType.RowIdDescriptor:
buffer = new byte [Size];
Marshal.Copy (Value, buffer, 0, Size);
// Get length of returned string
int rsize = 0;
//IntPtr env = Parent.Parent; // Parent is statement, grandparent is environment
IntPtr env = conn.Environment;
int status = OciCalls.OCICharSetToUnicode (env, null, buffer, out rsize);
OciErrorHandle.ThrowExceptionIfError (ErrorHandle, status);
// Get string
StringBuilder ret = new StringBuilder(rsize);
status = OciCalls.OCICharSetToUnicode (env, ret, buffer, out rsize);
OciErrorHandle.ThrowExceptionIfError (ErrorHandle, status);
return ret.ToString ();
case OciDataType.LongVarChar:
case OciDataType.Long:
buffer = new byte [LongVarCharMaxValue];
Marshal.Copy (Value, buffer, 0, buffer.Length);
int longSize = 0;
if (BitConverter.IsLittleEndian)
longSize = BitConverter.ToInt32 (new byte[]{buffer[0], buffer[1], buffer[2], buffer[3]}, 0);
else
longSize = BitConverter.ToInt32 (new byte[]{buffer[3], buffer[2], buffer[1], buffer[0]}, 0);
ASCIIEncoding encoding = new ASCIIEncoding ();
string e = encoding.GetString (buffer, 4, longSize);
return e;
case OciDataType.Integer:
case OciDataType.Number:
case OciDataType.Float:
case OciDataType.VarNum:
case OciDataType.UnsignedInt:
tmp = Marshal.PtrToStringAnsi (Value, Size);
if (tmp != null)
return Decimal.Parse (String.Copy ((string) tmp), formatProvider);
break;
case OciDataType.TimeStamp:
return dateTimeDesc.GetDateTime (conn.Environment, dateTimeDesc.ErrorHandle);
case OciDataType.Date:
return UnpackDate ();
case OciDataType.Raw:
case OciDataType.VarRaw:
byte [] raw_buffer = new byte [Size];
Marshal.Copy (Value, raw_buffer, 0, Size);
return raw_buffer;
case OciDataType.LongRaw:
case OciDataType.LongVarRaw:
buffer = new byte [LongVarRawMaxValue];
Marshal.Copy (Value, buffer, 0, buffer.Length);
int longrawSize = 0;
if (BitConverter.IsLittleEndian)
longrawSize = BitConverter.ToInt32 (new byte[]{buffer[0], buffer[1], buffer[2], buffer[3]}, 0);
else
longrawSize = BitConverter.ToInt32 (new byte[]{buffer[3], buffer[2], buffer[1], buffer[0]}, 0);
byte[] longraw_buffer = new byte [longrawSize];
Array.ConstrainedCopy (buffer, 4, longraw_buffer, 0, longrawSize);
return longraw_buffer;
case OciDataType.Blob:
case OciDataType.Clob:
return GetOracleLob ();
case OciDataType.IntervalDayToSecond:
return new OracleTimeSpan (intervalDesc.GetDayToSecond (conn.Environment, intervalDesc.ErrorHandle));
case OciDataType.IntervalYearToMonth:
return new OracleMonthSpan (intervalDesc.GetYearToMonth (conn.Environment, intervalDesc.ErrorHandle));
default:
throw new Exception("OciDataType not implemented: " + DataType.ToString ());
}
return DBNull.Value;
}
internal object GetOracleValue (IFormatProvider formatProvider, OracleConnection conn)
{
object ovalue = GetValue (formatProvider, conn);
switch (DataType) {
case OciDataType.Raw:
case OciDataType.VarRaw:
case OciDataType.LongRaw:
case OciDataType.LongVarRaw:
return new OracleBinary ((byte[]) ovalue);
case OciDataType.Date:
case OciDataType.TimeStamp:
return new OracleDateTime ((DateTime) ovalue);
case OciDataType.Blob:
case OciDataType.Clob:
OracleLob lob = (OracleLob) ovalue;
return lob;
case OciDataType.Integer:
case OciDataType.Number:
case OciDataType.Float:
case OciDataType.VarNum:
case OciDataType.UnsignedInt:
return new OracleNumber ((decimal) ovalue);
case OciDataType.VarChar2:
case OciDataType.String:
case OciDataType.VarChar:
case OciDataType.Char:
case OciDataType.CharZ:
case OciDataType.OciString:
case OciDataType.LongVarChar:
case OciDataType.Long:
case OciDataType.RowIdDescriptor:
return new OracleString ((string) ovalue);
case OciDataType.IntervalDayToSecond:
return new OracleTimeSpan ((OracleTimeSpan) ovalue);
case OciDataType.IntervalYearToMonth:
return new OracleMonthSpan ((OracleMonthSpan) ovalue);
default:
// TODO: do other types
throw new NotImplementedException ();
}
}
[MonoTODO ("Be able to handle negative dates... i.e. BCE.")]
internal DateTime UnpackDate ()
{
byte century = Marshal.ReadByte (value, 0);
byte year = Marshal.ReadByte (value, 1);
byte month = Marshal.ReadByte (value, 2);
byte day = Marshal.ReadByte (value, 3);
byte hour = Marshal.ReadByte (value, 4);
byte minute = Marshal.ReadByte (value, 5);
byte second = Marshal.ReadByte (value, 6);
if (hour == 0)
hour ++;
if (minute == 0)
minute ++;
if (second == 0)
second ++;
return new DateTime ((century - 100) * 100 + (year - 100),
month,
day,
hour - 1,
minute - 1,
second - 1);
}
#endregion // Methods
}
}