private void ReleaseStatementHandle(OciStatementHandle statementHandle)
{
if ((this.Connection.State != ConnectionState.Closed) && (this._preparedStatementHandle != statementHandle))
{
OciHandle.SafeDispose(ref statementHandle);
}
}
/// <include file='doc\OracleDataReader.uex' path='docs/doc[@for="OracleDataReader.Close"]/*' />
public void Close()
{
// Note that we do this first, which triggers IsClosed to return true.
OciHandle.SafeDispose(ref _statementHandle);
Cleanup();
if (null != _refCursorDataReaders)
{
int i = _refCursorDataReaders.Length;
while (--i >= 0)
{
OracleDataReader refCursorDataReader = _refCursorDataReaders[i];
_refCursorDataReaders[i] = null;
if (null != refCursorDataReader)
{
refCursorDataReader.Dispose();
}
}
_refCursorDataReaders = null;
}
// If we were asked to close the connection when we're closed, then we need to
// do that now.
if (_closeConnectionToo && null != _connection)
{
_connection.Close();
}
_connection = null;
}
private bool NextResultInternal()
{
this.Cleanup();
if ((this._refCursorDataReaders == null) || (this._nextRefCursor >= this._refCursorDataReaders.Length))
{
this._endOfData = true;
this._hasRows = 1;
return(false);
}
if (this._nextRefCursor > 0)
{
this._refCursorDataReaders[this._nextRefCursor - 1].Dispose();
this._refCursorDataReaders[this._nextRefCursor - 1] = null;
}
OciStatementHandle handle = this._statementHandle;
this._statementHandle = this._refCursorDataReaders[this._nextRefCursor]._statementHandle;
OciHandle.SafeDispose(ref handle);
this._connection = this._refCursorDataReaders[this._nextRefCursor]._connection;
this._connectionCloseCount = this._refCursorDataReaders[this._nextRefCursor]._connectionCloseCount;
this._hasRows = this._refCursorDataReaders[this._nextRefCursor]._hasRows;
this._recordsAffected = this._refCursorDataReaders[this._nextRefCursor]._recordsAffected;
this._columnInfo = this._refCursorDataReaders[this._nextRefCursor]._columnInfo;
this._rowBufferLength = this._refCursorDataReaders[this._nextRefCursor]._rowBufferLength;
this._rowsToPrefetch = this._refCursorDataReaders[this._nextRefCursor]._rowsToPrefetch;
this._nextRefCursor++;
this._endOfData = false;
this._isLastBuffer = false;
this._rowsTotal = 0;
return(true);
}
protected override DbSqlParserColumnCollection GatherTableColumns(DbSqlParserTable table)
{
OciStatementHandle stmtp = new OciStatementHandle(this._connection.ServiceContextHandle);
OciErrorHandle errorHandle = this._connection.ErrorHandle;
StringBuilder builder = new StringBuilder();
string schemaName = table.SchemaName;
string tableName = table.TableName;
DbSqlParserColumnCollection columns = new DbSqlParserColumnCollection();
builder.Append("select * from ");
if (!System.Data.Common.ADP.IsEmpty(schemaName))
{
builder.Append(schemaName);
builder.Append(".");
}
builder.Append(tableName);
string stmt = builder.ToString();
if ((TracedNativeMethods.OCIStmtPrepare(stmtp, errorHandle, stmt, OCI.SYNTAX.OCI_NTV_SYNTAX, OCI.MODE.OCI_DEFAULT, this._connection) == 0) && (TracedNativeMethods.OCIStmtExecute(this._connection.ServiceContextHandle, stmtp, errorHandle, 0, OCI.MODE.OCI_DESCRIBE_ONLY) == 0))
{
int num3;
stmtp.GetAttribute(OCI.ATTR.OCI_ATTR_PARAM_COUNT, out num3, errorHandle);
for (int i = 0; i < num3; i++)
{
string str;
OciParameterDescriptor handle = stmtp.GetDescriptor(i, errorHandle);
handle.GetAttribute(OCI.ATTR.OCI_ATTR_SQLCODE, out str, errorHandle, this._connection);
OciHandle.SafeDispose(ref handle);
str = this.QuotePrefixCharacter + str + this.QuoteSuffixCharacter;
columns.Add(null, schemaName, tableName, str, null);
}
}
OciHandle.SafeDispose(ref stmtp);
return(columns);
}
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 void Dispose()
{
OciHandle.SafeDispose(ref this._bindHandle);
if (this._freeTemporaryLob)
{
OracleLob lob = this._coercedValue as OracleLob;
if (lob != null)
{
lob.Free();
}
}
}
internal void Dispose()
{
if (Interlocked.Decrement(ref this._cloneCount) == 0)
{
if ((this._openMode != 0) && !this.ConnectionIsClosed)
{
this.ForceClose();
}
OciHandle.SafeDispose(ref this._descriptor);
GC.KeepAlive(this);
this._connection = null;
}
}
public override void Prepare()
{
IntPtr ptr;
OracleConnection.ExecutePermission.Demand();
Bid.ScopeEnter(out ptr, "<ora.OracleCommand.Prepare|API> %d#\n", this.ObjectID);
try
{
if (this.ConnectionIsClosed)
{
throw System.Data.Common.ADP.ClosedConnectionError();
}
if (System.Data.CommandType.Text == this.CommandType)
{
short num2;
OciStatementHandle statementHandle = this.GetStatementHandle();
int closeCount = this._connection.CloseCount;
string statementText = this.StatementText;
int rc = TracedNativeMethods.OCIStmtPrepare(statementHandle, this.ErrorHandle, statementText, OCI.SYNTAX.OCI_NTV_SYNTAX, OCI.MODE.OCI_DEFAULT, this.Connection);
if (rc != 0)
{
this.Connection.CheckError(this.ErrorHandle, rc);
}
statementHandle.GetAttribute(OCI.ATTR.OCI_ATTR_STMT_TYPE, out num2, this.ErrorHandle);
this._statementType = (OCI.STMT)num2;
if (OCI.STMT.OCI_STMT_SELECT == this._statementType)
{
rc = TracedNativeMethods.OCIStmtExecute(this._connection.ServiceContextHandle, statementHandle, this.ErrorHandle, 0, OCI.MODE.OCI_DESCRIBE_ONLY);
if (rc != 0)
{
this.Connection.CheckError(this.ErrorHandle, rc);
}
}
if (statementHandle != this._preparedStatementHandle)
{
OciHandle.SafeDispose(ref this._preparedStatementHandle);
}
this._preparedStatementHandle = statementHandle;
this._preparedAtCloseCount = closeCount;
}
else if (this._preparedStatementHandle != null)
{
OciHandle.SafeDispose(ref this._preparedStatementHandle);
}
}
finally
{
Bid.ScopeLeave(ref ptr);
}
}
internal void Dispose()
{
int cloneCount = Interlocked.Decrement(ref _cloneCount);
if (0 == cloneCount)
{
if (0 != _openMode && !ConnectionIsClosed)
{
ForceClose();
}
OciHandle.SafeDispose(ref _descriptor);
GC.KeepAlive(this);
_connection = null;
}
}
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();
}
public override int ExecuteNonQuery()
{
int num;
IntPtr ptr;
OracleConnection.ExecutePermission.Demand();
Bid.ScopeEnter(out ptr, "<ora.OracleCommand.ExecuteNonQuery|API> %d#\n", this.ObjectID);
try
{
OciRowidDescriptor rowidDescriptor = null;
int num2 = this.ExecuteNonQueryInternal(false, out rowidDescriptor);
OciHandle.SafeDispose(ref rowidDescriptor);
num = num2;
}
finally
{
Bid.ScopeLeave(ref ptr);
}
return(num);
}
public override object ExecuteScalar()
{
object obj2;
IntPtr ptr;
OracleConnection.ExecutePermission.Demand();
Bid.ScopeEnter(out ptr, "<ora.OracleCommand.ExecuteScalar|API> %d#\n", this.ObjectID);
try
{
OciRowidDescriptor descriptor;
object obj3 = this.ExecuteScalarInternal(true, false, out descriptor);
OciHandle.SafeDispose(ref descriptor);
obj2 = obj3;
}
finally
{
Bid.ScopeLeave(ref ptr);
}
return(obj2);
}
public int ExecuteOracleNonQuery(out OracleString rowid)
{
int num;
IntPtr ptr;
OracleConnection.ExecutePermission.Demand();
Bid.ScopeEnter(out ptr, "<ora.OracleCommand.ExecuteOracleNonQuery|API> %d#\n", this.ObjectID);
try
{
OciRowidDescriptor rowidDescriptor = null;
int num2 = this.ExecuteNonQueryInternal(true, out rowidDescriptor);
rowid = GetPersistedRowid(this.Connection, rowidDescriptor);
OciHandle.SafeDispose(ref rowidDescriptor);
num = num2;
}
finally
{
Bid.ScopeLeave(ref ptr);
}
return(num);
}
public override void Close()
{
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<ora.OracleDataReader.Close|API> %d#\n", this.ObjectID);
try
{
OciHandle.SafeDispose(ref this._statementHandle);
this.Cleanup();
if (this._refCursorDataReaders != null)
{
int length = this._refCursorDataReaders.Length;
while (--length >= 0)
{
OracleDataReader reader = this._refCursorDataReaders[length];
this._refCursorDataReaders[length] = null;
if (reader != null)
{
reader.Dispose();
}
}
this._refCursorDataReaders = null;
}
if (this._closeConnectionToo && (this._connection != null))
{
this._connection.Close();
}
this._connection = null;
this._fieldNameLookup = null;
this._schemaTable = null;
}
finally
{
Bid.ScopeLeave(ref ptr);
}
}
private bool NextResultInternal()
{
Cleanup();
if (null == _refCursorDataReaders || _nextRefCursor >= _refCursorDataReaders.Length)
{
_endOfData = true; // force current result to be done.
_hasRows = x_hasRows_False;
return(false);
}
if (_nextRefCursor > 0)
{
_refCursorDataReaders[_nextRefCursor - 1].Dispose();
_refCursorDataReaders[_nextRefCursor - 1] = null;
}
OciHandle oldStatementHandle = _statementHandle;
_statementHandle = _refCursorDataReaders[_nextRefCursor]._statementHandle;
OciHandle.SafeDispose(ref oldStatementHandle);
_connection = _refCursorDataReaders[_nextRefCursor]._connection;
_connectionCloseCount = _refCursorDataReaders[_nextRefCursor]._connectionCloseCount;
_hasRows = _refCursorDataReaders[_nextRefCursor]._hasRows;
_recordsAffected = _refCursorDataReaders[_nextRefCursor]._recordsAffected;
_columnInfo = _refCursorDataReaders[_nextRefCursor]._columnInfo;
_rowBufferLength = _refCursorDataReaders[_nextRefCursor]._rowBufferLength;
_rowsToPrefetch = _refCursorDataReaders[_nextRefCursor]._rowsToPrefetch;
_nextRefCursor++;
_endOfData = false;
_isLastBuffer = false;
_rowsTotal = 0;
return(true);
}
internal void Bind(
OciHandle statementHandle,
NativeBuffer buffer,
OciHandle errorHandle,
int rowBufferLength
)
{
// Binds the buffer for the column to the statement handle specified.
OciHandle defineHandle = null;
IntPtr h;
OCI.MODE mode = OCI.MODE.OCI_DEFAULT;
int bindSize;
OCI.DATATYPE ociType = _metaType.OciType;
_rowBuffer = buffer;
if (_metaType.IsLong)
{
mode = OCI.MODE.OCI_DYNAMIC_FETCH;
bindSize = Int32.MaxValue;
}
else
{
bindSize = _size;
}
HandleRef indicatorLocation = ADP.NullHandleRef;
HandleRef lengthLocation = ADP.NullHandleRef;
HandleRef valueLocation = _rowBuffer.PtrOffset(_valueOffset);
if (-1 != _indicatorOffset)
{
indicatorLocation = _rowBuffer.PtrOffset(_indicatorOffset);
}
if (-1 != _lengthOffset && !_metaType.IsLong)
{
lengthLocation = _rowBuffer.PtrOffset(_lengthOffset);
}
try
{
try
{
int rc = TracedNativeMethods.OCIDefineByPos(
statementHandle, // hndlp
out h, // defnpp
errorHandle, // errhp
_ordinal + 1, // position
valueLocation, // valuep
bindSize, // value_sz
ociType, // htype
indicatorLocation, // indp,
lengthLocation, // rlenp,
ADP.NullHandleRef, // rcodep,
mode // mode
);
if (rc != 0)
{
_connection.CheckError(errorHandle, rc);
}
defineHandle = new OciDefineHandle(statementHandle, h);
if (0 != rowBufferLength)
{
int valOffset = rowBufferLength;
int indOffset = (-1 != _indicatorOffset) ? rowBufferLength : 0;
int lenOffset = (-1 != _lengthOffset && !_metaType.IsLong) ? rowBufferLength : 0;
rc = TracedNativeMethods.OCIDefineArrayOfStruct(
defineHandle,
errorHandle,
valOffset,
indOffset,
lenOffset,
0 // never use rcodep above...
);
if (rc != 0)
{
_connection.CheckError(errorHandle, rc);
}
}
if (!_connection.UnicodeEnabled)
{
if (_metaType.UsesNationalCharacterSet)
{
Debug.Assert(!_metaType.IsLong, "LONG data may never be bound as NCHAR");
// NOTE: the order is important here; setting charsetForm will
// reset charsetId (I found this out the hard way...)
defineHandle.SetAttribute(OCI.ATTR.OCI_ATTR_CHARSET_FORM, (int)OCI.CHARSETFORM.SQLCS_NCHAR, errorHandle);
}
if (_bindAsUCS2)
{
// NOTE: the order is important here; setting charsetForm will
// reset charsetId (I found this out the hard way...)
defineHandle.SetAttribute(OCI.ATTR.OCI_ATTR_CHARSET_ID, OCI.OCI_UCS2ID, errorHandle);
}
}
if (_metaType.IsLong)
{
// Initialize the longBuffer in the rowBuffer to null
Marshal.WriteIntPtr((IntPtr)_rowBuffer.PtrOffset(_valueOffset), IntPtr.Zero);
if (null != _longBuffer)
{
_longBuffer.Dispose();
_longBuffer = null;
}
// We require MTxOCI8 to be in the path somewhere for us to handle LONG data
if (!OCI.IsNewMtxOci8Installed)
#if EVERETT
{ throw ADP.MustInstallNewMtxOciLONG(); }
#else //!EVERETT {
throw ADP.MustInstallNewMtxOci();
}
#endif //!EVERETT
_callback = new OCI.Callback.OCICallbackDefine(_callback_GetColumnPiecewise);
rc = TracedNativeMethods.MTxOciDefineDynamic(
defineHandle, // defnp
errorHandle, // errhp
ADP.NullHandleRef, // dvoid *octxp,
_callback // OCICallbackDefine ocbfp
);
if (rc != 0)
{
_connection.CheckError(errorHandle, rc);
}
}
}
finally
{
// We don't need this any longer, get rid of it.
OciHandle.SafeDispose(ref defineHandle);
}
}
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
//
// Methods
//
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
internal void Bind(
OciHandle statementHandle,
NativeBuffer parameterBuffer,
OracleConnection connection
)
{
IntPtr h;
// Don't bother with parameters where the user asks for the default value.
if (!IsDirection(Parameter, ParameterDirection.Output) && null == Parameter.Value)
{
return;
}
string parameterName = Parameter.ParameterName;
OciHandle errorHandle = connection.ErrorHandle;
OciHandle environmentHandle = connection.EnvironmentHandle;
int valueLength = 0;
OCI.INDICATOR indicatorValue = OCI.INDICATOR.OK;
int bufferLength;
OCI.DATATYPE ociType = _bindingMetaType.OciType;
HandleRef indicatorLocation = parameterBuffer.PtrOffset(_indicatorOffset);
HandleRef lengthLocation = parameterBuffer.PtrOffset(_lengthOffset);
HandleRef valueLocation = parameterBuffer.PtrOffset(_valueOffset);
if (IsDirection(Parameter, ParameterDirection.Input))
{
if (ADP.IsNull(_coercedValue))
{
indicatorValue = OCI.INDICATOR.ISNULL;
}
else
{
valueLength = PutOracleValue(
_coercedValue,
valueLocation,
_bindingMetaType,
connection);
}
}
else
{
Debug.Assert(IsDirection(Parameter, ParameterDirection.Output), "non-output output parameter?");
if (_bindingMetaType.IsVariableLength)
{
valueLength = 0; // Output-only values never have an input length...
}
else
{
valueLength = _bufferLengthInBytes; // ...except when they're fixed length, to avoid ORA-01459 errors
}
OciLobLocator.SafeDispose(ref _locator);
OciHandle.SafeDispose(ref _descriptor);
switch (ociType)
{
case OCI.DATATYPE.BFILE:
case OCI.DATATYPE.BLOB:
case OCI.DATATYPE.CLOB:
_locator = new OciLobLocator(connection, _bindingMetaType.OracleType);
break;
case OCI.DATATYPE.RSET:
_descriptor = new OciStatementHandle(environmentHandle);
break;
}
if (null != _locator)
{
Marshal.WriteIntPtr((IntPtr)valueLocation, (IntPtr)_locator.Handle);
}
else if (null != _descriptor)
{
Marshal.WriteIntPtr((IntPtr)valueLocation, (IntPtr)_descriptor.Handle);
}
}
Marshal.WriteInt16((IntPtr)indicatorLocation, (Int16)indicatorValue);
// Don't bind a length value for LONGVARCHAR or LONGVARRAW data, or you'll end
// up with ORA-01098: program Interface error during Long Insert\nORA-01458: invalid length inside variable character string
// errors.
if (OCI.DATATYPE.LONGVARCHAR == ociType ||
OCI.DATATYPE.LONGVARRAW == ociType)
{
lengthLocation = ADP.NullHandleRef;
}
else
{
// When we're binding this parameter as UCS2, the length we specify
// must be in characters, not in bytes.
if (_bindAsUCS2)
{
Marshal.WriteInt32((IntPtr)lengthLocation, (Int32)(valueLength / ADP.CharSize));
}
else
{
Marshal.WriteInt32((IntPtr)lengthLocation, (Int32)valueLength);
}
}
if (IsDirection(Parameter, ParameterDirection.Output))
{
bufferLength = _bufferLengthInBytes;
}
else
{
bufferLength = valueLength;
}
// Finally, tell Oracle about our parameter.
int rc = TracedNativeMethods.OCIBindByName(
statementHandle,
out h,
errorHandle,
parameterName,
parameterName.Length,
valueLocation,
bufferLength,
ociType,
indicatorLocation,
lengthLocation,
ADP.NullHandleRef,
0,
ADP.NullHandleRef,
OCI.MODE.OCI_DEFAULT
);
if (rc != 0)
{
_command.Connection.CheckError(errorHandle, rc);
}
_bindHandle = new OciBindHandle(statementHandle, h);
#if TRACEPARAMETERVALUES
if (null != _coercedValue)
{
SafeNativeMethods.OutputDebugStringW("Value = '" + _coercedValue.ToString() + "'\n");
}
#endif //TRACEPARAMETERVALUES
// OK, character bindings have a few extra things we need to do to
// deal with character sizes and alternate character sets.
if (_bindingMetaType.IsCharacterType)
{
// To avoid problems when our buffer is larger than the maximum number
// of characters, we use OCI_ATTR_MAXCHAR_SIZE to limit the number of
// characters that will be used. (Except on Oracle8i clients where it
// isn't available)
if (OCI.ClientVersionAtLeastOracle9i &&
IsDirection(Parameter, ParameterDirection.Output))
{
_bindHandle.SetAttribute(OCI.ATTR.OCI_ATTR_MAXCHAR_SIZE, (int)_bufferLength, errorHandle);
}
if ((bufferLength > _bindingMetaType.MaxBindSize / ADP.CharSize) ||
(!OCI.ClientVersionAtLeastOracle9i && _bindingMetaType.UsesNationalCharacterSet)) // need to specify MAXDATA_SIZE for OCI8 UCS2 bindings to work
{
_bindHandle.SetAttribute(OCI.ATTR.OCI_ATTR_MAXDATA_SIZE, (int)_bindingMetaType.MaxBindSize, errorHandle);
}
// NOTE: the order is important here; setting charsetForm will
// reset charsetId (I found this out the hard way...)
if (_bindingMetaType.UsesNationalCharacterSet)
{
_bindHandle.SetAttribute(OCI.ATTR.OCI_ATTR_CHARSET_FORM, (int)OCI.CHARSETFORM.SQLCS_NCHAR, errorHandle);
}
// NOTE: the order is important here; setting charsetForm will
// reset charsetId (I found this out the hard way...)
if (_bindAsUCS2)
{
_bindHandle.SetAttribute(OCI.ATTR.OCI_ATTR_CHARSET_ID, OCI.OCI_UCS2ID, errorHandle);
}
}
}
internal void Dispose()
{
OciHandle.SafeDispose(ref _bindHandle);
}
internal static int DetermineClientVersion()
{
if (_clientVersion == 0)
{
int num = 0;
MODE environmentMode = MODE.OCI_DATA_AT_EXEC | MODE.OCI_BATCH_MODE;
try
{
System.Data.Common.UnsafeNativeMethods.OCILobCopy2(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 0L, 0L, 0L);
num = 0x65;
}
catch (EntryPointNotFoundException exception6)
{
System.Data.Common.ADP.TraceException(exception6);
try
{
OciHandle handle = new OciNlsEnvironmentHandle(environmentMode);
if (!handle.IsInvalid)
{
num = 0x5c;
OciHandle.SafeDispose(ref handle);
}
}
catch (EntryPointNotFoundException exception5)
{
System.Data.Common.ADP.TraceException(exception5);
try
{
environmentMode |= MODE.OCI_UTF16;
OciHandle handle2 = new OciEnvironmentHandle(environmentMode, true);
num = 90;
OciHandle.SafeDispose(ref handle2);
}
catch (EntryPointNotFoundException exception4)
{
System.Data.Common.ADP.TraceException(exception4);
num = 80;
}
catch (Exception exception)
{
if (!System.Data.Common.ADP.IsCatchableExceptionType(exception))
{
throw;
}
System.Data.Common.ADP.TraceException(exception);
num = 0x51;
}
}
}
catch (DllNotFoundException exception3)
{
System.Data.Common.ADP.TraceException(exception3);
num = 0x49;
}
catch (BadImageFormatException exception2)
{
throw System.Data.Common.ADP.BadOracleClientImageFormat(exception2);
}
if (0x51 > num)
{
throw System.Data.Common.ADP.BadOracleClientVersion();
}
_clientVersion = num;
}
return(_clientVersion);
}
internal void Bind(OciStatementHandle statementHandle, NativeBuffer_RowBuffer buffer, OciErrorHandle errorHandle, int rowBufferLength)
{
OciDefineHandle defnp = null;
int num3;
OCI.MODE mode = OCI.MODE.OCI_DEFAULT;
OCI.DATATYPE ociType = this._metaType.OciType;
this._rowBuffer = buffer;
if (this._metaType.IsLong)
{
mode = OCI.MODE.OCI_DATA_AT_EXEC;
num3 = 0x7fffffff;
}
else
{
num3 = this._byteSize;
}
IntPtr zero = IntPtr.Zero;
IntPtr rlenp = IntPtr.Zero;
IntPtr dataPtr = this._rowBuffer.DangerousGetDataPtr(this._valueOffset);
if (-1 != this._indicatorOffset)
{
zero = this._rowBuffer.DangerousGetDataPtr(this._indicatorOffset);
}
if ((-1 != this._lengthOffset) && !this._metaType.IsLong)
{
rlenp = this._rowBuffer.DangerousGetDataPtr(this._lengthOffset);
}
try
{
IntPtr ptr3;
int rc = TracedNativeMethods.OCIDefineByPos(statementHandle, out ptr3, errorHandle, ((uint)this._ordinal) + 1, dataPtr, num3, ociType, zero, rlenp, IntPtr.Zero, mode);
if (rc != 0)
{
this._connection.CheckError(errorHandle, rc);
}
defnp = new OciDefineHandle(statementHandle, ptr3);
if (rowBufferLength != 0)
{
uint pvskip = (uint)rowBufferLength;
uint indskip = (-1 != this._indicatorOffset) ? pvskip : 0;
uint rlskip = ((-1 != this._lengthOffset) && !this._metaType.IsLong) ? pvskip : 0;
rc = TracedNativeMethods.OCIDefineArrayOfStruct(defnp, errorHandle, pvskip, indskip, rlskip, 0);
if (rc != 0)
{
this._connection.CheckError(errorHandle, rc);
}
}
if (this._metaType.UsesNationalCharacterSet)
{
defnp.SetAttribute(OCI.ATTR.OCI_ATTR_CHARSET_FORM, 2, errorHandle);
}
if (!this._connection.UnicodeEnabled && this._bindAsUTF16)
{
defnp.SetAttribute(OCI.ATTR.OCI_ATTR_CHARSET_ID, 0x3e8, errorHandle);
}
if (this._metaType.IsLong)
{
this._rowBuffer.WriteIntPtr(this._valueOffset, IntPtr.Zero);
this._callback = new OCI.Callback.OCICallbackDefine(this._callback_GetColumnPiecewise);
rc = TracedNativeMethods.OCIDefineDynamic(defnp, errorHandle, IntPtr.Zero, this._callback);
if (rc != 0)
{
this._connection.CheckError(errorHandle, rc);
}
}
}
finally
{
NativeBuffer.SafeDispose(ref this._longBuffer);
OciHandle.SafeDispose(ref defnp);
}
}
internal void Bind(OciStatementHandle statementHandle, NativeBuffer parameterBuffer, OracleConnection connection, ref bool mustRelease, ref SafeHandle handleToBind)
{
if (IsDirection(this.Parameter, ParameterDirection.Output) || (this.Parameter.Value != null))
{
int num2;
IntPtr ptr2;
string parameterName = this.Parameter.ParameterName;
OciErrorHandle errorHandle = connection.ErrorHandle;
OciServiceContextHandle serviceContextHandle = connection.ServiceContextHandle;
int num = 0;
OCI.INDICATOR oK = OCI.INDICATOR.OK;
OCI.DATATYPE ociType = this._bindingMetaType.OciType;
IntPtr dataPtr = parameterBuffer.DangerousGetDataPtr(this._indicatorOffset);
IntPtr alenp = parameterBuffer.DangerousGetDataPtr(this._lengthOffset);
IntPtr valuep = parameterBuffer.DangerousGetDataPtr(this._valueOffset);
OciHandle.SafeDispose(ref this._dateTimeDescriptor);
if (IsDirection(this.Parameter, ParameterDirection.Input))
{
if (System.Data.Common.ADP.IsNull(this._coercedValue))
{
oK = OCI.INDICATOR.ISNULL;
switch (ociType)
{
case OCI.DATATYPE.INT_TIMESTAMP:
case OCI.DATATYPE.INT_TIMESTAMP_TZ:
case OCI.DATATYPE.INT_TIMESTAMP_LTZ:
this._dateTimeDescriptor = OracleDateTime.CreateEmptyDescriptor(ociType, connection);
handleToBind = this._dateTimeDescriptor;
break;
}
}
else
{
num = this.PutOracleValue(this._coercedValue, parameterBuffer, this._valueOffset, this._bindingMetaType, connection, ref handleToBind);
}
}
else
{
if (this._bindingMetaType.IsVariableLength)
{
num = 0;
}
else
{
num = this._bufferLength;
}
OciLobLocator.SafeDispose(ref this._locator);
OciHandle.SafeDispose(ref this._descriptor);
switch (ociType)
{
case OCI.DATATYPE.CLOB:
case OCI.DATATYPE.BLOB:
case OCI.DATATYPE.BFILE:
this._locator = new OciLobLocator(connection, this._bindingMetaType.OracleType);
handleToBind = this._locator.Descriptor;
break;
case OCI.DATATYPE.RSET:
this._descriptor = new OciStatementHandle(serviceContextHandle);
handleToBind = this._descriptor;
break;
case OCI.DATATYPE.INT_TIMESTAMP:
case OCI.DATATYPE.INT_TIMESTAMP_TZ:
case OCI.DATATYPE.INT_TIMESTAMP_LTZ:
this._dateTimeDescriptor = OracleDateTime.CreateEmptyDescriptor(ociType, connection);
handleToBind = this._dateTimeDescriptor;
break;
}
}
if (handleToBind != null)
{
handleToBind.DangerousAddRef(ref mustRelease);
parameterBuffer.WriteIntPtr(this._valueOffset, handleToBind.DangerousGetHandle());
}
parameterBuffer.WriteInt16(this._indicatorOffset, (short)oK);
if ((OCI.DATATYPE.LONGVARCHAR == ociType) || (OCI.DATATYPE.LONGVARRAW == ociType))
{
alenp = IntPtr.Zero;
}
else if (this._bindAsUCS2)
{
parameterBuffer.WriteInt32(this._lengthOffset, num / System.Data.Common.ADP.CharSize);
}
else
{
parameterBuffer.WriteInt32(this._lengthOffset, num);
}
if (IsDirection(this.Parameter, ParameterDirection.Output))
{
num2 = this._bufferLength;
}
else
{
num2 = num;
}
OCI.DATATYPE dty = ociType;
switch (ociType)
{
case OCI.DATATYPE.INT_TIMESTAMP:
dty = OCI.DATATYPE.TIMESTAMP;
break;
case OCI.DATATYPE.INT_TIMESTAMP_TZ:
dty = OCI.DATATYPE.TIMESTAMP_TZ;
break;
case OCI.DATATYPE.INT_TIMESTAMP_LTZ:
dty = OCI.DATATYPE.TIMESTAMP_LTZ;
break;
}
int rc = TracedNativeMethods.OCIBindByName(statementHandle, out ptr2, errorHandle, parameterName, parameterName.Length, valuep, num2, dty, dataPtr, alenp, OCI.MODE.OCI_DEFAULT);
if (rc != 0)
{
this._command.Connection.CheckError(errorHandle, rc);
}
this._bindHandle = new OciBindHandle(statementHandle, ptr2);
if (this._bindingMetaType.IsCharacterType)
{
if (OCI.ClientVersionAtLeastOracle9i && IsDirection(this.Parameter, ParameterDirection.Output))
{
this._bindHandle.SetAttribute(OCI.ATTR.OCI_ATTR_MAXCHAR_SIZE, this._bindSize, errorHandle);
}
if ((num2 > (this._bindingMetaType.MaxBindSize / System.Data.Common.ADP.CharSize)) || (!OCI.ClientVersionAtLeastOracle9i && this._bindingMetaType.UsesNationalCharacterSet))
{
this._bindHandle.SetAttribute(OCI.ATTR.OCI_ATTR_MAXDATA_SIZE, this._bindingMetaType.MaxBindSize, errorHandle);
}
if (this._bindingMetaType.UsesNationalCharacterSet)
{
this._bindHandle.SetAttribute(OCI.ATTR.OCI_ATTR_CHARSET_FORM, 2, errorHandle);
}
if (this._bindAsUCS2)
{
this._bindHandle.SetAttribute(OCI.ATTR.OCI_ATTR_CHARSET_ID, 0x3e8, errorHandle);
}
}
GC.KeepAlive(parameterBuffer);
}
}
private bool OpenOnLocalTransaction(string userName, string password, string serverName, bool integratedSecurity, bool unicode, bool omitOracleConnectionName)
{
int rc = 0;
OCI.MODE environmentMode = OCI.MODE.OCI_DATA_AT_EXEC | OCI.MODE.OCI_BATCH_MODE;
OCI.DetermineClientVersion();
if (unicode)
{
if (OCI.ClientVersionAtLeastOracle9i)
{
environmentMode |= OCI.MODE.OCI_UTF16;
}
else
{
unicode = false;
}
}
this._environmentHandle = new OciEnvironmentHandle(environmentMode, unicode);
if (this._environmentHandle.IsInvalid)
{
throw System.Data.Common.ADP.CouldNotCreateEnvironment("OCIEnvCreate", rc);
}
this._errorHandle = new OciErrorHandle(this._environmentHandle);
this._serverHandle = new OciServerHandle(this._errorHandle);
this._sessionHandle = new OciSessionHandle(this._serverHandle);
this._serviceContextHandle = new OciServiceContextHandle(this._sessionHandle);
try
{
OCI.CRED cred;
rc = TracedNativeMethods.OCIServerAttach(this._serverHandle, this._errorHandle, serverName, serverName.Length, OCI.MODE.OCI_DEFAULT);
if (rc != 0)
{
if (1 == rc)
{
this.CreateDeferredInfoMessage(this.ErrorHandle, rc);
}
else
{
OracleException.Check(this.ErrorHandle, rc);
}
}
this._serviceContextHandle.SetAttribute(OCI.ATTR.OCI_ATTR_SERVER, this._serverHandle, this._errorHandle);
if (integratedSecurity)
{
cred = OCI.CRED.OCI_CRED_EXT;
}
else
{
cred = OCI.CRED.OCI_CRED_RDBMS;
this._sessionHandle.SetAttribute(OCI.ATTR.OCI_ATTR_USERNAME, userName, this._errorHandle);
if (password != null)
{
this._sessionHandle.SetAttribute(OCI.ATTR.OCI_ATTR_PASSWORD, password, this._errorHandle);
}
}
if (!omitOracleConnectionName)
{
string dataSource = this._connectionOptions.DataSource;
if (dataSource.Length > 0x10)
{
dataSource = dataSource.Substring(0, 0x10);
}
this._serverHandle.SetAttribute(OCI.ATTR.OCI_ATTR_EXTERNAL_NAME, dataSource, this._errorHandle);
this._serverHandle.SetAttribute(OCI.ATTR.OCI_ATTR_INTERNAL_NAME, dataSource, this._errorHandle);
}
rc = TracedNativeMethods.OCISessionBegin(this._serviceContextHandle, this._errorHandle, this._sessionHandle, cred, OCI.MODE.OCI_DEFAULT);
if (rc != 0)
{
if (1 == rc)
{
this.CreateDeferredInfoMessage(this.ErrorHandle, rc);
}
else
{
OracleException.Check(this.ErrorHandle, rc);
}
}
this._serviceContextHandle.SetAttribute(OCI.ATTR.OCI_ATTR_SESSION, this._sessionHandle, this._errorHandle);
}
catch (OracleException)
{
OciHandle.SafeDispose(ref this._serviceContextHandle);
OciHandle.SafeDispose(ref this._sessionHandle);
OciHandle.SafeDispose(ref this._serverHandle);
OciHandle.SafeDispose(ref this._errorHandle);
OciHandle.SafeDispose(ref this._environmentHandle);
throw;
}
return(true);
}
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 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);
}
override protected DBSqlParserColumnCollection GatherTableColumns(
DBSqlParserTable table
)
{
// Called to get a column list for the table specified.
OciHandle statementHandle = _connection.EnvironmentHandle.CreateOciHandle(OCI.HTYPE.OCI_HTYPE_STMT);
OciHandle errorHandle = _connection.ErrorHandle;
StringBuilder sb = new StringBuilder();
string schemaName = table.SchemaName;
string tableName = table.TableName;
string columnName;
int tableColumnCount;
int rc;
string tempStatement;
DBSqlParserColumnCollection columns = new DBSqlParserColumnCollection();
Debug.Assert(string.Empty == table.DatabaseName, "oracle doesn't support 4 part names!");
sb.Append("select * from ");
if (String.Empty != schemaName)
{
sb.Append(schemaName);
sb.Append(".");
}
sb.Append(tableName);
tempStatement = sb.ToString();
rc = TracedNativeMethods.OCIStmtPrepare(
statementHandle,
errorHandle,
tempStatement,
tempStatement.Length,
OCI.SYNTAX.OCI_NTV_SYNTAX,
OCI.MODE.OCI_DEFAULT,
_connection
);
if (0 == rc)
{
rc = TracedNativeMethods.OCIStmtExecute(
_connection.ServiceContextHandle,
statementHandle,
errorHandle,
0, // iters
0, // rowoff
ADP.NullHandleRef, // snap_in
ADP.NullHandleRef, // snap_out
OCI.MODE.OCI_DESCRIBE_ONLY // mode
);
if (0 == rc)
{
// Build the column list for the table
statementHandle.GetAttribute(OCI.ATTR.OCI_ATTR_PARAM_COUNT, out tableColumnCount, errorHandle);
for (int j = 0; j < tableColumnCount; j++)
{
OciHandle describeHandle = statementHandle.GetDescriptor(j, errorHandle);
describeHandle.GetAttribute(OCI.ATTR.OCI_ATTR_NAME, out columnName, errorHandle, _connection);
OciHandle.SafeDispose(ref describeHandle);
columnName = QuotePrefixCharacter + columnName + QuoteSuffixCharacter;
columns.Add(null, schemaName, tableName, columnName, null);
}
// Now, derive the key information for the statement and update the column list
// with it.
}
}
// Clean up and return;
OciHandle.SafeDispose(ref statementHandle);
return(columns);
}
