Files
mono/mcs/class/System.Data.OracleClient/System.Data.OracleClient/OracleParameter.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

1508 lines
40 KiB
C#

//
// OracleParameter.cs
//
// Part of the Mono class libraries at
// mcs/class/System.Data.OracleClient/System.Data.OracleClient
//
// Assembly: System.Data.OracleClient.dll
// Namespace: System.Data.OracleClient
//
// Authors:
// Tim Coleman <[email protected]>
// Daniel Moragn <[email protected]>
// Hubert FONGARNAND <[email protected]>
// Veerapuram Varadhan <[email protected]>
//
// Copyright (C) Tim Coleman , 2003
// Copyright (C) Daniel Morgan, 2005, 2008, 2009
// Copyright (C) Hubert FONGARNAND, 2005
// Copyright (C) Novell Inc, 2009
//
// Licensed under the MIT/X11 License.
//
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
#if NET_2_0
using System.Data.Common;
#endif
using System.Data.SqlTypes;
using System.Data.OracleClient.Oci;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Text;
namespace System.Data.OracleClient
{
[TypeConverter (typeof(OracleParameter.OracleParameterConverter))]
public sealed class OracleParameter :
#if NET_2_0
DbParameter, IDbDataParameter, ICloneable,
#else
MarshalByRefObject, IDbDataParameter, IDataParameter, ICloneable,
#endif
IDisposable
{
#region Fields
string name;
OracleType oracleType = OracleType.VarChar;
OciDataType ociType;
int size;
ParameterDirection direction = ParameterDirection.Input;
bool isNullable;
byte precision;
byte scale;
string srcColumn;
#if NET_2_0
bool sourceColumnNullMapping;
#endif
DataRowVersion srcVersion;
DbType dbType = DbType.AnsiString;
int offset;
bool sizeSet;
bool oracleTypeSet;
object value = DBNull.Value;
OciLobLocator lobLocator; // only if Blob or Clob
IntPtr bindOutValue = IntPtr.Zero;
IntPtr indicator = IntPtr.Zero;
OciDateTimeDescriptor dateTimeDesc;
IntPtr cursor = IntPtr.Zero;
OracleParameterCollection container;
OciBindHandle bindHandle;
OracleConnection connection;
byte[] bytes;
IntPtr bindValue = IntPtr.Zero;
bool useRef;
OciDataType bindType;
int bindSize;
bool sizeManuallySet;
#endregion // Fields
#region Constructors
// constructor for cloning the object
private OracleParameter (OracleParameter value)
{
this.name = value.name;
this.oracleType = value.oracleType;
this.ociType = value.ociType;
this.size = value.size;
this.direction = value.direction;
this.isNullable = value.isNullable;
this.precision = value.precision;
this.scale = value.scale;
this.srcColumn = value.srcColumn;
this.srcVersion = value.srcVersion;
this.dbType = value.dbType;
this.offset = value.offset;
this.sizeSet = value.sizeSet;
this.value = value.value;
this.lobLocator = value.lobLocator;
this.oracleTypeSet = value.oracleTypeSet;
this.indicator = OciCalls.AllocateClear (sizeof(short));
}
public OracleParameter ()
{
this.name = String.Empty;
this.oracleType = OracleType.VarChar;
this.size = 0;
this.direction = ParameterDirection.Input;
this.isNullable = false;
this.precision = 0;
this.scale = 0;
this.srcColumn = String.Empty;
this.srcVersion = DataRowVersion.Current;
this.value = null;
this.oracleTypeSet = false;
this.indicator = OciCalls.AllocateClear (sizeof(short));
}
public OracleParameter (string name, object value)
{
this.name = name;
this.value = value;
srcColumn = string.Empty;
SourceVersion = DataRowVersion.Current;
InferOracleType (value);
this.indicator = OciCalls.AllocateClear (sizeof(short));
#if NET_2_0
// Find the OciType before inferring for the size
if (value != null && value != DBNull.Value) {
this.sizeSet = true;
this.size = InferSize ();
}
#endif
}
public OracleParameter (string name, OracleType oracleType)
: this (name, oracleType, 0, ParameterDirection.Input, false, 0, 0, String.Empty, DataRowVersion.Current, null)
{
}
public OracleParameter (string name, OracleType oracleType, int size)
: this (name, oracleType, size, ParameterDirection.Input, false, 0, 0, String.Empty, DataRowVersion.Current, null)
{
}
public OracleParameter (string name, OracleType oracleType, int size, string srcColumn)
: this (name, oracleType, size, ParameterDirection.Input, false, 0, 0, srcColumn, DataRowVersion.Current, null)
{
}
#if NET_2_0
public OracleParameter (string name, OracleType oracleType, int size, ParameterDirection direction, string sourceColumn, DataRowVersion sourceVersion, bool sourceColumnNullMapping, object value)
{
this.name = name;
if (size < 0)
throw new ArgumentException("Size must be not be negative.");
this.value = value;
this.size = size;
Direction = direction;
// set sizeSet to true iff value is not-null or non-zero size value
if (((value != null && value != DBNull.Value) || Direction == ParameterDirection.Output) &&
size > 0)
this.sizeSet = true;
SourceColumnNullMapping = sourceColumnNullMapping;
OracleType = oracleType;
SourceColumn = sourceColumn;
SourceVersion = sourceVersion;
this.indicator = OciCalls.AllocateClear (sizeof(short));
}
#endif
public OracleParameter (string name, OracleType oracleType, int size, ParameterDirection direction, bool isNullable, byte precision, byte scale, string srcColumn, DataRowVersion srcVersion, object value)
{
this.name = name;
if (size < 0)
throw new ArgumentException("Size must be not be negative.");
this.value = value;
this.size = size;
Direction = direction;
// set sizeSet to true iff value is not-null or non-zero size value
if (((value != null && value != DBNull.Value) || Direction == ParameterDirection.Output) &&
size > 0)
this.sizeSet = true;
this.isNullable = isNullable;
this.precision = precision;
this.scale = scale;
OracleType = oracleType;
SourceColumn = srcColumn;
SourceVersion = srcVersion;
this.indicator = OciCalls.AllocateClear (sizeof(short));
}
~OracleParameter ()
{
Dispose(false);
}
#endregion // Constructors
#region Properties
internal OracleParameterCollection Container {
get { return container; }
set { container = value; }
}
internal short Indicator {
get { return (Marshal.ReadInt16(indicator)); }
set { Marshal.WriteInt16(indicator, value); }
}
#if !NET_2_0
[Browsable (false)]
[RefreshProperties (RefreshProperties.All)]
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
#endif
public
#if NET_2_0
override
#endif
DbType DbType {
get { return dbType; }
set { SetDbType (value); }
}
#if !NET_2_0
[DefaultValue (ParameterDirection.Input)]
#endif
[RefreshProperties (RefreshProperties.All)]
public
#if NET_2_0
override
#endif
ParameterDirection Direction {
get { return direction; }
set {
direction = value;
if (this.size > 0 && direction == ParameterDirection.Output)
this.sizeSet = true;
}
}
#if !NET_2_0
[Browsable (false)]
[DesignOnly (true)]
[DefaultValue (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
#endif
public
#if NET_2_0
override
#endif
bool IsNullable {
get { return isNullable; }
set { isNullable = value; }
}
#if NET_2_0
[EditorBrowsable (EditorBrowsableState.Advanced)]
#else
[DefaultValue (0)]
#endif
[Browsable (false)]
public int Offset {
get { return offset; }
set { offset = value; }
}
[DefaultValue (OracleType.VarChar)]
[RefreshProperties (RefreshProperties.All)]
#if NET_2_0
[DbProviderSpecificTypeProperty (true)]
#endif
public OracleType OracleType {
get { return oracleType; }
set {
oracleTypeSet = true;
SetOracleType (value, false);
}
}
#if !NET_2_0
[DefaultValue ("")]
#endif
public
#if NET_2_0
override
#endif
string ParameterName {
get {
if (name == null)
return string.Empty;
return name;
}
set { name = value; }
}
#if NET_2_0
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
[Obsolete("Set the precision of a decimal use the Math classes.")]
#else
[DefaultValue (0)]
#endif
public byte Precision {
get { return precision; }
set { /* NO EFFECT*/ }
}
#if NET_2_0
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
[Obsolete("Set the precision of a decimal use the Math classes.")]
#else
[DefaultValue (0)]
#endif
public byte Scale {
get { return scale; }
set { /* NO EFFECT*/ }
}
#if !NET_2_0
[DefaultValue (0)]
#endif
public
#if NET_2_0
override
#endif
int Size {
get { return size; }
set {
sizeSet = true;
size = value;
sizeManuallySet = true;
}
}
#if !NET_2_0
[DefaultValue ("")]
#endif
public
#if NET_2_0
override
#endif
string SourceColumn {
get { return srcColumn; }
set { srcColumn = value; }
}
#if NET_2_0
[MonoTODO]
public override bool SourceColumnNullMapping {
get { return sourceColumnNullMapping; }
set { sourceColumnNullMapping = value; }
}
#endif
#if !NET_2_0
[DefaultValue ("Current")]
#endif
public
#if NET_2_0
override
#endif
DataRowVersion SourceVersion {
get { return srcVersion; }
set { srcVersion = value; }
}
#if !NET_2_0
[DefaultValue (null)]
#endif
[RefreshProperties (RefreshProperties.All)]
[TypeConverter (typeof(StringConverter))]
public
#if NET_2_0
override
#endif
object Value {
get { return this.value; }
set {
this.value = value;
if (!oracleTypeSet)
InferOracleType (value);
#if NET_2_0
if (value != null && value != DBNull.Value) {
this.size = InferSize ();
this.sizeSet = true;
}
#endif
}
}
#endregion // Properties
#region Methods
private void AssertSizeIsSet ()
{
switch (ociType) {
case OciDataType.VarChar2:
case OciDataType.String:
case OciDataType.VarChar:
case OciDataType.Char:
case OciDataType.CharZ:
case OciDataType.OciString:
if (!sizeSet)
throw new Exception ("Size must be set.");
break;
default:
break;
}
}
internal void Bind (OciStatementHandle statement, OracleConnection con, uint pos)
{
connection = con;
if (bindHandle == null)
bindHandle = new OciBindHandle ((OciHandle) statement);
IntPtr tmpHandle = bindHandle.Handle;
if (Direction != ParameterDirection.Input)
AssertSizeIsSet ();
if (!sizeSet)
size = InferSize ();
bindSize = size;
object v = value;
int status = 0;
bindType = ociType;
int rsize = 0;
string svalue;
string sDate;
DateTime dt;
bool isnull = false;
int byteCount;
byte[] byteArrayLen;
if (direction == ParameterDirection.Input || direction == ParameterDirection.InputOutput) {
if (v == null)
isnull = true;
else if (v is DBNull)
isnull = true;
else {
INullable mynullable = v as INullable;
if (mynullable != null)
isnull = mynullable.IsNull;
}
}
if (isnull == true && direction == ParameterDirection.Input) {
bindType = OciDataType.VarChar2;
bindSize = 0;
} else {
switch(ociType) {
case OciDataType.VarChar2:
case OciDataType.String:
case OciDataType.VarChar:
case OciDataType.Char:
case OciDataType.CharZ:
case OciDataType.OciString:
bindType = OciDataType.String;
svalue = "\0";
// convert value from managed type to type to marshal
if (direction == ParameterDirection.Input ||
direction == ParameterDirection.InputOutput) {
svalue = v.ToString ();
if (direction == ParameterDirection.Input && size > 0 && svalue.Length > size)
svalue = svalue.Substring(0, size);
svalue = svalue.ToString () + '\0';
// convert managed type to memory allocated earlier
// in this case using OCIUnicodeToCharSet
rsize = 0;
// Get size of buffer
status = OciCalls.OCIUnicodeToCharSet (statement.Parent, null, svalue, out rsize);
if (direction == ParameterDirection.Input)
bindSize = rsize;
else {
// this cannot be rsize because you need room for the output after the execute
bindSize = Encoding.UTF8.GetMaxByteCount (Size + 1);
}
// allocate memory based on bind size
bytes = new byte [bindSize];
// Fill buffer
status = OciCalls.OCIUnicodeToCharSet (statement.Parent, bytes, svalue, out rsize);
} else {
// for Output and ReturnValue parameters, get size in bytes
bindSize = Encoding.UTF8.GetMaxByteCount (size + 1);
// allocate memory for oracle to place the results for the Return or Output param
bytes = new byte [bindSize];
}
break;
case OciDataType.Date:
bindType = OciDataType.Date;
bindSize = 7;
// convert value from managed type to type to marshal
if (direction == ParameterDirection.Input ||
direction == ParameterDirection.InputOutput) {
if (isnull)
bytes = new byte [7];
else {
sDate = "";
dt = DateTime.MinValue;
if (v is String) {
sDate = (string) v;
dt = DateTime.Parse (sDate);
}
else if (v is DateTime)
dt = (DateTime) v;
else if (v is OracleString) {
sDate = v.ToString ();
dt = DateTime.Parse (sDate);
}
else if (v is OracleDateTime) {
OracleDateTime odt = (OracleDateTime) v;
dt = (DateTime) odt.Value;
}
else
throw new NotImplementedException ("For OracleType.DateTime, data type not implemented: " + v.GetType().ToString() + ".");
// for Input and InputOuput, create byte array and pack DateTime into it
bytes = PackDate (dt);
}
} else {
// allocate 7-byte array for Output and ReturnValue to put date
bytes = new byte [7];
}
break;
case OciDataType.TimeStamp:
dateTimeDesc = (OciDateTimeDescriptor) connection.Environment.Allocate (OciHandleType.TimeStamp);
if (dateTimeDesc == null) {
OciErrorInfo info = connection.ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
dateTimeDesc.ErrorHandle = connection.ErrorHandle;
bindSize = 11;
bindType = OciDataType.TimeStamp;
bindOutValue = dateTimeDesc.Handle;
bindValue = dateTimeDesc.Handle;
useRef = true;
if (direction == ParameterDirection.Input ||
direction == ParameterDirection.InputOutput) {
dt = DateTime.MinValue;
sDate = "";
if (isnull)
Indicator = -1;
else if (v is String) {
sDate = (string) v;
dt = DateTime.Parse (sDate);
}
else if (v is DateTime)
dt = (DateTime) v;
else if (v is OracleString) {
sDate = (string) v;
dt = DateTime.Parse (sDate);
}
else if (v is OracleDateTime) {
OracleDateTime odt = (OracleDateTime) v;
dt = (DateTime) odt.Value;
}
else
throw new NotImplementedException ("For OracleType.Timestamp, data type not implemented: " + v.GetType().ToString()); // ?
short year = (short) dt.Year;
byte month = (byte) dt.Month;
byte day = (byte) dt.Day;
byte hour = (byte) dt.Hour;
byte min = (byte) dt.Minute;
byte sec = (byte) dt.Second;
uint fsec = (uint) dt.Millisecond;
string timezone = "";
dateTimeDesc.SetDateTime (connection.Session,
connection.ErrorHandle,
year, month, day, hour, min, sec, fsec,
timezone);
}
break;
case OciDataType.Integer:
case OciDataType.Float:
case OciDataType.Number:
bindType = OciDataType.String;
Indicator = 0;
svalue = "\0";
// convert value from managed type to type to marshal
if (direction == ParameterDirection.Input ||
direction == ParameterDirection.InputOutput) {
svalue = null;
if(v is IFormattable)
svalue = ((IFormattable)v).ToString (null, con.SessionFormatProvider);
else if (v is OracleNumber)
svalue = ((OracleNumber)v).ToString(con.SessionFormatProvider);
else
svalue = v.ToString();
svalue = svalue + "\0";
rsize = 0;
// Get size of buffer
OciCalls.OCIUnicodeToCharSet (statement.Parent, null, svalue, out rsize);
// Fill buffer
if (direction == ParameterDirection.Input)
bindSize = rsize;
else
bindSize = 30; // need room for output possibly being bigger than the input
bytes = new byte [bindSize];
OciCalls.OCIUnicodeToCharSet (statement.Parent, bytes, svalue, out rsize);
} else {
// Output and ReturnValue parameters allocate memory
bindSize = 30;
bytes = new byte [bindSize];
}
break;
case OciDataType.Long:
case OciDataType.LongVarChar:
bindType = OciDataType.LongVarChar;
// FIXME: use piecewise fetching for Long, Clob, Blob, and Long Raw
// See http://download.oracle.com/docs/cd/B19306_01/appdev.102/b14250/oci05bnd.htm#sthref724
bindSize = Size + 5; // 4 bytes prepended for length, bytes, 1 byte NUL character
Indicator = 0;
svalue = "\0";
// convert value from managed type to type to marshal
if (direction == ParameterDirection.Input ||
direction == ParameterDirection.InputOutput) {
svalue = v.ToString () + '\0';
}
bytes = new byte [bindSize];
// LONG is only ANSI
ASCIIEncoding enc = new ASCIIEncoding ();
if (direction == ParameterDirection.Input ||
direction == ParameterDirection.InputOutput) {
if (svalue.Length > 0) {
byteCount = enc.GetBytes (svalue, 4, svalue.Length, bytes, 0);
// LONG VARCHAR prepends a 4-byte length
if (byteCount > 0) {
byteArrayLen = BitConverter.GetBytes ((uint) byteCount);
bytes[0] = byteArrayLen[0];
bytes[1] = byteArrayLen[1];
bytes[2] = byteArrayLen[2];
bytes[3] = byteArrayLen[3];
}
}
}
break;
case OciDataType.Clob:
if (direction == ParameterDirection.Input) {
svalue = v.ToString();
rsize = 0;
// Get size of buffer
OciCalls.OCIUnicodeToCharSet (statement.Parent, null, svalue, out rsize);
// Fill buffer
bytes = new byte[rsize];
OciCalls.OCIUnicodeToCharSet (statement.Parent, bytes, svalue, out rsize);
bindType = OciDataType.Long;
bindSize = bytes.Length;
}
else if (direction == ParameterDirection.InputOutput) {
// not the exact error that .net 2.0 throws, but this is better
throw new NotImplementedException ("Parameters of OracleType.Clob with direction of InputOutput are not supported.");
}
else {
// Output and Return parameters
bindSize = -1;
lobLocator = (OciLobLocator) connection.Environment.Allocate (OciHandleType.LobLocator);
if (lobLocator == null) {
OciErrorInfo info = connection.ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
bindOutValue = lobLocator.Handle;
bindValue = lobLocator.Handle;
lobLocator.ErrorHandle = connection.ErrorHandle;
lobLocator.Service = statement.Service;
lobLocator.Environment = connection.Environment;
useRef = true;
}
break;
case OciDataType.Blob:
if (direction == ParameterDirection.Input) {
if (v is byte[]) {
bytes = (byte[]) v;
bindType = OciDataType.LongRaw;
bindSize = bytes.Length;
}
else if (v is OracleLob) {
OracleLob lob = (OracleLob) v;
if (lob.LobType == OracleType.Blob) {
lobLocator = lob.Locator;
bindOutValue = lobLocator.Handle;
bindValue = lobLocator.Handle;
lobLocator.ErrorHandle = connection.ErrorHandle;
lobLocator.Service = connection.ServiceContext;
useRef = true;
}
else
throw new NotImplementedException("For OracleType.Blob, data type OracleLob of LobType Clob/NClob is not implemented.");
}
else
throw new NotImplementedException ("For OracleType.Blob, data type not implemented: " + v.GetType().ToString()); // ?
}
else if (direction == ParameterDirection.InputOutput) {
// not the exact error that .net 2.0 throws, but this is better
throw new NotImplementedException ("Parameters of OracleType.Blob with direction of InputOutput are not supported.");
}
else {
bindSize = -1;
if (value != null && value is OracleLob) {
OracleLob blob = (OracleLob) value;
if (blob.LobType == OracleType.Blob)
if (value != OracleLob.Null) {
lobLocator = blob.Locator;
byte[] bs = (byte[]) blob.Value;
bindSize = bs.Length;
}
}
if (lobLocator == null) {
lobLocator = (OciLobLocator) connection.Environment.Allocate (OciHandleType.LobLocator);
if (lobLocator == null) {
OciErrorInfo info = connection.ErrorHandle.HandleError ();
throw new OracleException (info.ErrorCode, info.ErrorMessage);
}
}
bindOutValue = lobLocator.Handle;
bindValue = lobLocator.Handle;
lobLocator.ErrorHandle = connection.ErrorHandle;
lobLocator.Service = connection.ServiceContext;
lobLocator.Environment = connection.Environment;
useRef = true;
}
break;
case OciDataType.Raw:
case OciDataType.VarRaw:
bindType = OciDataType.VarRaw;
bindSize = Size + 2; // include 2 bytes prepended to hold the length
Indicator = 0;
bytes = new byte [bindSize];
if (direction == ParameterDirection.Input ||
direction == ParameterDirection.InputOutput) {
byteCount = 0;
byte[] val;
if (dbType == DbType.Guid)
val = ((Guid)v).ToByteArray();
else
val = v as byte[];
if (val.Length > 0) {
byteCount = val.Length;
// LONG VARRAW prepends a 4-byte length
if (byteCount > 0) {
byteArrayLen = BitConverter.GetBytes ((ushort) byteCount);
bytes[0] = byteArrayLen[0];
bytes[1] = byteArrayLen[1];
Array.ConstrainedCopy (val, 0, bytes, 2, byteCount);
}
}
}
break;
case OciDataType.LongRaw:
case OciDataType.LongVarRaw:
bindType = OciDataType.LongVarRaw;
bindSize = Size + 4; // include 4 bytes prepended to hold the length
Indicator = 0;
bytes = new byte [bindSize];
if (direction == ParameterDirection.Input ||
direction == ParameterDirection.InputOutput) {
byteCount = 0;
byte[] val = v as byte[];
if (val.Length > 0) {
byteCount = val.Length;
// LONG VARRAW prepends a 4-byte length
if (byteCount > 0) {
byteArrayLen = BitConverter.GetBytes ((uint) byteCount);
bytes[0] = byteArrayLen[0];
bytes[1] = byteArrayLen[1];
bytes[2] = byteArrayLen[2];
bytes[3] = byteArrayLen[3];
Array.ConstrainedCopy (val, 0, bytes, 4, byteCount);
}
}
}
break;
case OciDataType.RowIdDescriptor:
if (direction == ParameterDirection.Output ||
direction == ParameterDirection.InputOutput ||
direction == ParameterDirection.ReturnValue) {
size = 10;
bindType = OciDataType.Char;
bindSize = size * 2;
bindOutValue = OciCalls.AllocateClear (bindSize);
bindValue = bindOutValue;
} else
throw new NotImplementedException("data type RowIdDescriptor as Intput parameters");
break;
case OciDataType.RSet: // REF CURSOR
if (direction == ParameterDirection.Output ||
direction == ParameterDirection.InputOutput ||
direction == ParameterDirection.ReturnValue) {
if (cursor != IntPtr.Zero) {
OciCalls.OCIHandleFree (cursor,
OciHandleType.Statement);
cursor = IntPtr.Zero;
}
OciCalls.OCIHandleAlloc (connection.Environment,
out cursor,
OciHandleType.Statement,
0,
IntPtr.Zero);
bindSize = 0;
bindType = OciDataType.RSet;
} else
throw new NotImplementedException ("data type Ref Cursor not implemented for Input parameters");
break;
default:
throw new NotImplementedException ("Data Type not implemented: " + ociType.ToString() + ".");
}
}
// Now, call the appropriate OCI Bind function;
if (useRef == true) {
if (bindType == OciDataType.TimeStamp) {
bindValue = dateTimeDesc.Handle;
status = OciCalls.OCIBindByNameRef (statement,
out tmpHandle,
connection.ErrorHandle,
ParameterName,
ParameterName.Length,
ref bindValue,
bindSize,
bindType,
indicator,
IntPtr.Zero,
IntPtr.Zero,
0,
IntPtr.Zero,
0);
}
else {
status = OciCalls.OCIBindByNameRef (statement,
out tmpHandle,
connection.ErrorHandle,
ParameterName,
ParameterName.Length,
ref bindValue,
bindSize,
bindType,
indicator,
IntPtr.Zero,
IntPtr.Zero,
0,
IntPtr.Zero,
0);
}
}
else if (bindType == OciDataType.RSet) {
status = OciCalls.OCIBindByNameRef (statement,
out tmpHandle,
connection.ErrorHandle,
ParameterName,
ParameterName.Length,
ref cursor,
bindSize,
bindType,
indicator,
IntPtr.Zero,
IntPtr.Zero,
0,
IntPtr.Zero,
0);
}
else if (bytes != null) {
status = OciCalls.OCIBindByNameBytes (statement,
out tmpHandle,
connection.ErrorHandle,
ParameterName,
ParameterName.Length,
bytes,
bindSize,
bindType,
indicator,
IntPtr.Zero,
IntPtr.Zero,
0,
IntPtr.Zero,
0);
}
else {
status = OciCalls.OCIBindByName (statement,
out tmpHandle,
connection.ErrorHandle,
ParameterName,
ParameterName.Length, // FIXME: this should be in bytes!
bindValue,
bindSize,
bindType,
indicator,
IntPtr.Zero,
IntPtr.Zero,
0,
IntPtr.Zero,
0);
}
OciErrorHandle.ThrowExceptionIfError (connection.ErrorHandle, status);
bindHandle.SetHandle (tmpHandle);
}
object ICloneable.Clone ()
{
return new OracleParameter(this);
}
private void InferOracleType (object value)
{
// Should we throw an exception here?
if (value == null || value == DBNull.Value)
return;
Type type = value.GetType ();
string exception = String.Format ("The parameter data type of {0} is invalid.", type.FullName);
switch (type.FullName) {
case "System.Int64":
SetOracleType (OracleType.Number, true);
break;
case "System.Boolean":
case "System.Byte":
SetOracleType (OracleType.Byte, true);
break;
case "System.String":
case "System.Data.OracleClient.OracleString":
SetOracleType (OracleType.VarChar, true);
break;
case "System.Data.OracleClient.OracleDateTime":
case "System.DateTime":
SetOracleType (OracleType.DateTime, true);
break;
case "System.Decimal":
case "System.Data.OracleClient.OracleNumber":
SetOracleType (OracleType.Number, true);
break;
case "System.Double":
SetOracleType (OracleType.Double, true);
break;
case "System.Byte[]":
case "System.Guid":
SetOracleType (OracleType.Raw, true);
break;
case "System.Int32":
SetOracleType (OracleType.Int32, true);
break;
case "System.Single":
SetOracleType (OracleType.Float, true);
break;
case "System.Int16":
SetOracleType (OracleType.Int16, true);
break;
case "System.DBNull":
break; //unable to guess type
case "System.Data.OracleClient.OracleLob":
SetOracleType (((OracleLob) value).LobType, true);
break;
default:
throw new ArgumentException (exception);
}
}
private int InferSize ()
{
int newSize = 0;
switch (ociType) {
case OciDataType.VarChar2:
case OciDataType.String:
case OciDataType.VarChar:
case OciDataType.Char:
case OciDataType.CharZ:
case OciDataType.OciString:
case OciDataType.Long:
case OciDataType.LongVarChar:
if (sizeManuallySet == true)
return size;
if (value == null || value == DBNull.Value)
newSize = 0;
else
newSize = value.ToString ().Length;
break;
case OciDataType.RowIdDescriptor:
newSize = 10;
break;
case OciDataType.Integer:
case OciDataType.Number:
case OciDataType.Float:
newSize = 22;
break;
case OciDataType.Date:
newSize = 7;
break;
case OciDataType.TimeStamp:
newSize = 11;
break;
case OciDataType.Blob:
case OciDataType.Clob:
case OciDataType.RSet: // REF CURSOR
newSize = -1;
break;
case OciDataType.Raw:
if (dbType == DbType.Guid)
newSize = ((Guid)value).ToByteArray().Length;
else
newSize = (value as byte[]).Length;
break;
default:
if (value == null || value == DBNull.Value)
newSize = 0;
else
newSize = value.ToString ().Length;
break;
}
sizeSet = true;
return newSize;
}
private void SetDbType (DbType type)
{
string exception = String.Format ("No mapping exists from DbType {0} to a known OracleType.", type);
switch (type) {
case DbType.AnsiString:
oracleType = OracleType.VarChar;
ociType = OciDataType.VarChar;
break;
case DbType.AnsiStringFixedLength:
oracleType = OracleType.Char;
ociType = OciDataType.Char;
break;
case DbType.Binary:
case DbType.Guid:
oracleType = OracleType.Raw;
ociType = OciDataType.Raw;
break;
case DbType.Boolean:
case DbType.Byte:
oracleType = OracleType.Byte;
ociType = OciDataType.Integer;
break;
case DbType.Currency:
case DbType.Decimal:
case DbType.Int64:
oracleType = OracleType.Number;
ociType = OciDataType.Number;
break;
case DbType.Date:
case DbType.DateTime:
case DbType.Time:
oracleType = OracleType.DateTime;
ociType = OciDataType.Char;
break;
case DbType.Double:
oracleType = OracleType.Double;
ociType = OciDataType.Float;
break;
case DbType.Int16:
oracleType = OracleType.Int16;
ociType = OciDataType.Integer;
break;
case DbType.Int32:
oracleType = OracleType.Int32;
ociType = OciDataType.Integer;
break;
case DbType.Object:
oracleType = OracleType.Blob;
ociType = OciDataType.Blob;
break;
case DbType.Single:
oracleType = OracleType.Float;
ociType = OciDataType.Float;
break;
case DbType.String:
oracleType = OracleType.NVarChar;
ociType = OciDataType.VarChar;
break;
case DbType.StringFixedLength:
oracleType = OracleType.NChar;
ociType = OciDataType.Char;
break;
default:
throw new ArgumentException (exception);
}
dbType = type;
}
private void SetOracleType (OracleType type, bool inferring)
{
Type valType;
FreeHandle ();
if (value == null)
valType = typeof(System.DBNull);
else
valType = value.GetType ();
string exception = String.Format ("No mapping exists from OracleType {0} to a known DbType.", type);
switch (type) {
case OracleType.BFile:
case OracleType.Blob:
dbType = DbType.Binary;
ociType = OciDataType.Blob;
break;
case OracleType.LongRaw:
case OracleType.Raw:
if (valType.FullName == "System.Guid")
dbType = DbType.Guid;
else
dbType = DbType.Binary;
ociType = OciDataType.Raw;
break;
case OracleType.Byte:
dbType = DbType.Byte;
ociType = OciDataType.Number;
break;
case OracleType.Char:
dbType = DbType.AnsiString;
ociType = OciDataType.Char;
break;
case OracleType.Clob:
dbType = DbType.AnsiString;
ociType = OciDataType.Clob;
break;
case OracleType.LongVarChar:
case OracleType.RowId:
case OracleType.VarChar:
dbType = DbType.AnsiString;
ociType = OciDataType.VarChar;
break;
case OracleType.Cursor: // REF CURSOR
ociType = OciDataType.RSet;
dbType = DbType.Object;
break;
case OracleType.IntervalDayToSecond:
dbType = DbType.AnsiStringFixedLength;
ociType = OciDataType.Char;
break;
case OracleType.Timestamp:
case OracleType.TimestampLocal:
case OracleType.TimestampWithTZ:
dbType = DbType.DateTime;
ociType = OciDataType.TimeStamp;
break;
case OracleType.DateTime:
dbType = DbType.DateTime;
ociType = OciDataType.Date;
break;
case OracleType.Double:
dbType = DbType.Double;
ociType = OciDataType.Number;
break;
case OracleType.Float:
dbType = DbType.Single;
ociType = OciDataType.Number;
break;
case OracleType.Int16:
dbType = DbType.Int16;
ociType = OciDataType.Number;
break;
case OracleType.Int32:
case OracleType.IntervalYearToMonth:
dbType = DbType.Int32;
ociType = OciDataType.Number;
break;
case OracleType.NChar:
dbType = DbType.StringFixedLength;
ociType = OciDataType.Char;
break;
case OracleType.NClob:
case OracleType.NVarChar:
dbType = DbType.String;
ociType = OciDataType.Char;
break;
case OracleType.Number:
dbType = DbType.VarNumeric;
ociType = OciDataType.Number;
break;
case OracleType.SByte:
dbType = DbType.SByte;
ociType = OciDataType.Number;
break;
case OracleType.UInt16:
dbType = DbType.UInt16;
ociType = OciDataType.Number;
break;
case OracleType.UInt32:
dbType = DbType.UInt32;
ociType = OciDataType.Number;
break;
default:
throw new ArgumentException (exception);
}
if (!oracleTypeSet || !inferring )
oracleType = type;
}
#if NET_2_0
public override void ResetDbType ()
{
ResetOracleType ();
}
public void ResetOracleType ()
{
oracleTypeSet = false;
InferOracleType (value);
}
#endif // NET_2_0
public override string ToString ()
{
return ParameterName;
}
private void GetOutValue (OracleCommand cmd)
{
// used to update the parameter value
// for Output, the output of InputOutput, and Return parameters
value = DBNull.Value;
if (Indicator == -1)
return;
int rsize = 0;
IntPtr env = IntPtr.Zero;
StringBuilder ret = null;
// FIXME: redo all types - see how Char, Number, and Date are done
// here and in Bind()
switch (ociType) {
case OciDataType.VarChar2:
case OciDataType.String:
case OciDataType.VarChar:
case OciDataType.Char:
case OciDataType.CharZ:
case OciDataType.OciString:
case OciDataType.RowIdDescriptor:
// Get length of returned string
rsize = 0;
env = cmd.Connection.Environment;
OciCalls.OCICharSetToUnicode (env, null, bytes, out rsize);
// Get string
ret = new StringBuilder(rsize);
OciCalls.OCICharSetToUnicode (env, ret, bytes, out rsize);
value = ret.ToString ();
break;
case OciDataType.Long:
case OciDataType.LongVarChar:
int longSize = 0;
if (BitConverter.IsLittleEndian)
longSize = BitConverter.ToInt32 (new byte [] {bytes [0], bytes [1], bytes [2], bytes [3]}, 0);
else
longSize = BitConverter.ToInt32 (new byte [] {bytes [3], bytes [2], bytes [1], bytes [0]}, 0);
ASCIIEncoding encoding = new ASCIIEncoding ();
value = encoding.GetString (bytes, 4, longSize);
encoding = null;
break;
case OciDataType.LongRaw:
case OciDataType.LongVarRaw:
int longrawSize = 0;
if (BitConverter.IsLittleEndian)
longrawSize = BitConverter.ToInt32 (new byte [] {bytes [0], bytes [1], bytes [2], bytes [3]}, 0);
else
longrawSize = BitConverter.ToInt32 (new byte [] {bytes [3], bytes [2], bytes [1], bytes [0]}, 0);
byte[] longraw_buffer = new byte [longrawSize];
Array.ConstrainedCopy (bytes, 4, longraw_buffer, 0, longrawSize);
value = longraw_buffer;
break;
case OciDataType.Raw:
case OciDataType.VarRaw:
int rawSize = 0;
if (BitConverter.IsLittleEndian)
rawSize = (int) BitConverter.ToInt16 (new byte [] {bytes [0], bytes [1]}, 0);
else
rawSize = (int) BitConverter.ToInt16 (new byte [] {bytes [1], bytes [0]}, 0);
byte[] raw_buffer = new byte [rawSize];
Array.ConstrainedCopy (bytes, 2, raw_buffer, 0, rawSize);
value = raw_buffer;
break;
case OciDataType.Integer:
case OciDataType.Number:
case OciDataType.Float:
rsize = 0;
env = cmd.Connection.Environment;
OciCalls.OCICharSetToUnicode (env, null, bytes, out rsize);
// Get string
ret = new StringBuilder(rsize);
OciCalls.OCICharSetToUnicode (env, ret, bytes, out rsize);
// if not empty, parse string as a decimal using session format
if (ret.Length > 0) {
switch (dbType) {
case DbType.UInt16:
value = UInt16.Parse (ret.ToString (), cmd.Connection.SessionFormatProvider);
break;
case DbType.UInt32:
value = UInt32.Parse (ret.ToString (), cmd.Connection.SessionFormatProvider);
break;
case DbType.Int16:
value = Int16.Parse (ret.ToString (), cmd.Connection.SessionFormatProvider);
break;
case DbType.Int32:
value = Int32.Parse (ret.ToString (), cmd.Connection.SessionFormatProvider);
break;
default:
value = Decimal.Parse (ret.ToString (), cmd.Connection.SessionFormatProvider);
break;
}
}
break;
case OciDataType.TimeStamp:
value = dateTimeDesc.GetDateTime (connection.Environment, dateTimeDesc.ErrorHandle);
break;
case OciDataType.Date:
value = UnpackDate (bytes);
break;
case OciDataType.Blob:
case OciDataType.Clob:
if (value != null && value is OracleLob && value != OracleLob.Null) {
OracleLob lob2 = (OracleLob) value;
lob2.connection = connection;
}
else {
OracleLob lob = new OracleLob (lobLocator, ociType);
lob.connection = connection;
value = lob;
}
break;
case OciDataType.RSet: // REF CURSOR
OciStatementHandle cursorStatement = GetOutRefCursor (cmd);
value = new OracleDataReader (cursorStatement.Command, cursorStatement, true, CommandBehavior.Default);
break;
default:
throw new NotImplementedException ("Data Type not implemented: " + ociType.ToString() + ".");
}
}
internal OciStatementHandle GetOutRefCursor (OracleCommand cmd)
{
OciStatementHandle cursorStatement = new OciStatementHandle (cmd.Connection.ServiceContext, cursor);
cursorStatement.ErrorHandle = cmd.ErrorHandle;
cursorStatement.Command = cmd;
cursorStatement.SetupRefCursorResult (cmd.Connection);
cursorStatement.Service = cmd.Connection.ServiceContext;
cursor = IntPtr.Zero;
return cursorStatement;
}
internal void Update (OracleCommand cmd)
{
if (Direction != ParameterDirection.Input)
GetOutValue (cmd);
FreeHandle ();
}
internal void FreeHandle ()
{
switch (ociType) {
case OciDataType.Clob:
case OciDataType.Blob:
lobLocator = null;
break;
case OciDataType.TimeStamp:
break;
default:
Marshal.FreeHGlobal (bindOutValue);
break;
}
bindOutValue = IntPtr.Zero;
bindValue = IntPtr.Zero;
bindHandle = null;
connection = null;
}
// copied from OciDefineHandle
[MonoTODO ("Be able to handle negative dates... i.e. BCE.")]
private DateTime UnpackDate (byte[] bytes)
{
byte century = bytes [0];
byte year = bytes [1];
byte month = bytes [2];
byte day = bytes [3];
byte hour = bytes [4];
byte minute = bytes [5];
byte second = bytes [6];
return new DateTime ((century - 100) * 100 + (year - 100),
month,
day,
hour - 1,
minute - 1,
second - 1);
}
private byte[] PackDate (DateTime dateValue)
{
byte[] buffer = new byte[7];
buffer[0] = (byte)((dateValue.Year / 100) + 100); //century
buffer[1] = (byte)((dateValue.Year % 100) + 100); // Year
buffer[2] = (byte)dateValue.Month;
buffer[3] = (byte)dateValue.Day;
buffer[4] = (byte)(dateValue.Hour+1);
buffer[5] = (byte)(dateValue.Minute+1);
buffer[6] = (byte)(dateValue.Second+1);
return buffer;
}
public void Dispose ()
{
Dispose (true);
}
void Dispose (bool disposing)
{
if (disposing) {
GC.SuppressFinalize(this);
}
if (indicator != IntPtr.Zero) {
Marshal.FreeHGlobal (indicator);
indicator = IntPtr.Zero;
}
}
#endregion // Methods
internal sealed class OracleParameterConverter : ExpandableObjectConverter
{
public OracleParameterConverter ()
{
}
[MonoTODO]
public override bool CanConvertTo (ITypeDescriptorContext context, Type destinationType)
{
throw new NotImplementedException ();
}
[MonoTODO]
public override object ConvertTo (ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
throw new NotImplementedException ();
}
}
}
}