Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / Data / System / Data / OleDb / OleDbCommand.cs / 1 / OleDbCommand.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
namespace System.Data.OleDb {
using System;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.ProviderBase;
using System.Diagnostics;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Text;
[
DefaultEvent("RecordsAffected"),
ToolboxItem(true),
Designer("Microsoft.VSDesigner.Data.VS.OleDbCommandDesigner, " + AssemblyRef.MicrosoftVSDesigner)
]
#if WINFSInternalOnly
internal
#else
public
#endif
sealed class OleDbCommand : DbCommand, ICloneable, IDbCommand {
// command data
private string _commandText;
private CommandType _commandType;
private int _commandTimeout = ADP.DefaultCommandTimeout;
private UpdateRowSource _updatedRowSource = UpdateRowSource.Both;
private bool _designTimeInvisible;
private OleDbConnection _connection;
private OleDbTransaction _transaction;
private static int _objectTypeCount; // Bid counter
internal readonly int ObjectID = System.Threading.Interlocked.Increment(ref _objectTypeCount);
private OleDbParameterCollection _parameters;
// native information
private UnsafeNativeMethods.ICommandText _icommandText;
// if executing with a different CommandBehavior.KeyInfo behavior
// original ICommandText must be released and a new ICommandText generated
private CommandBehavior commandBehavior;
private Bindings _dbBindings;
internal bool canceling; // MDAC 68964
private bool _isPrepared;
private bool _executeQuery;
private bool _trackingForClose;
private bool _hasDataReader;
private IntPtr _recordsAffected;
private int _changeID;
private int _lastChangeID;
public OleDbCommand() : base() {
GC.SuppressFinalize(this);
}
public OleDbCommand(string cmdText) : this() {
CommandText = cmdText;
}
public OleDbCommand(string cmdText, OleDbConnection connection) : this() {
CommandText = cmdText;
Connection = connection;
}
public OleDbCommand(string cmdText, OleDbConnection connection, OleDbTransaction transaction) : this() {
CommandText = cmdText;
Connection = connection;
Transaction = transaction;
}
private OleDbCommand(OleDbCommand from) : this() { // Clone
CommandText = from.CommandText;
CommandTimeout = from.CommandTimeout;
CommandType = from.CommandType;
Connection = from.Connection;
DesignTimeVisible = from.DesignTimeVisible;
UpdatedRowSource = from.UpdatedRowSource;
Transaction = from.Transaction;
OleDbParameterCollection parameters = Parameters;
foreach(object parameter in from.Parameters) {
parameters.Add((parameter is ICloneable) ? (parameter as ICloneable).Clone() : parameter);
}
}
private Bindings ParameterBindings {
get {
return _dbBindings;
}
set {
Bindings bindings = _dbBindings;
_dbBindings = value;
if ((null != bindings) && (value != bindings)) {
bindings.Dispose();
}
}
}
[
DefaultValue(""),
Editor("Microsoft.VSDesigner.Data.ADO.Design.OleDbCommandTextEditor, " + AssemblyRef.MicrosoftVSDesigner, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing),
RefreshProperties(RefreshProperties.All), // MDAC 67707
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbCommand_CommandText),
]
override public string CommandText {
get {
string value = _commandText;
return ((null != value) ? value : ADP.StrEmpty);
}
set {
if (Bid.TraceOn) {
Bid.Trace(" %d#, '", ObjectID);
Bid.PutStr(value); // Use PutStr to write out entire string
Bid.Trace("'\n");
}
if (0 != ADP.SrcCompare(_commandText, value)) {
PropertyChanging();
_commandText = value;
}
}
}
[
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbCommand_CommandTimeout),
]
override public int CommandTimeout { // V1.2.3300, XXXCommand V1.0.5000
get {
return _commandTimeout;
}
set {
Bid.Trace(" %d#, %d\n", ObjectID, value);
if (value < 0) {
throw ADP.InvalidCommandTimeout(value);
}
if (value != _commandTimeout) {
PropertyChanging();
_commandTimeout = value;
}
}
}
public void ResetCommandTimeout() { // V1.2.3300
if (ADP.DefaultCommandTimeout != _commandTimeout) {
PropertyChanging();
_commandTimeout = ADP.DefaultCommandTimeout;
}
}
private bool ShouldSerializeCommandTimeout() { // V1.2.3300
return (ADP.DefaultCommandTimeout != _commandTimeout);
}
[
DefaultValue(System.Data.CommandType.Text),
RefreshProperties(RefreshProperties.All),
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbCommand_CommandType),
]
override public CommandType CommandType {
get {
CommandType cmdType = _commandType;
return ((0 != cmdType) ? cmdType : CommandType.Text);
}
set {
switch(value) { // @perfnote: Enum.IsDefined
case CommandType.Text:
case CommandType.StoredProcedure:
case CommandType.TableDirect:
PropertyChanging();
_commandType = value;
break;
default:
throw ADP.InvalidCommandType(value);
}
}
}
[
DefaultValue(null),
Editor("Microsoft.VSDesigner.Data.Design.DbConnectionEditor, " + AssemblyRef.MicrosoftVSDesigner, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing),
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbCommand_Connection),
]
new public OleDbConnection Connection {
get {
return _connection;
}
set {
OleDbConnection connection = _connection;
if (value != connection) {
PropertyChanging();
ResetConnection();
_connection = value;
Bid.Trace(" %d#\n", ObjectID);
if (null != value) {
_transaction = OleDbTransaction.TransactionUpdate(_transaction); // MDAC 63226
}
}
}
}
private void ResetConnection() {
OleDbConnection connection = _connection;
if (null != connection) {
PropertyChanging();
CloseInternal();
if (_trackingForClose) {
connection.RemoveWeakReference(this);
_trackingForClose = false;
}
}
_connection = null;
}
override protected DbConnection DbConnection { // V1.2.3300
get {
return Connection;
}
set {
Connection = (OleDbConnection)value;
}
}
override protected DbParameterCollection DbParameterCollection { // V1.2.3300
get {
return Parameters;
}
}
override protected DbTransaction DbTransaction { // V1.2.3300
get {
return Transaction;
}
set {
Transaction = (OleDbTransaction)value;
}
}
// @devnote: By default, the cmd object is visible on the design surface (i.e. VS7 Server Tray)
// to limit the number of components that clutter the design surface,
// when the DataAdapter design wizard generates the insert/update/delete commands it will
// set the DesignTimeVisible property to false so that cmds won't appear as individual objects
[
DefaultValue(true),
DesignOnly(true),
Browsable(false),
EditorBrowsableAttribute(EditorBrowsableState.Never),
]
public override bool DesignTimeVisible { // V1.2.3300, XXXCommand V1.0.5000
get {
return !_designTimeInvisible;
}
set {
_designTimeInvisible = !value;
TypeDescriptor.Refresh(this); // VS7 208845
}
}
[
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbCommand_Parameters),
]
new public OleDbParameterCollection Parameters {
get {
OleDbParameterCollection value = _parameters;
if (null == value) {
// delay the creation of the OleDbParameterCollection
// until user actually uses the Parameters property
value = new OleDbParameterCollection();
_parameters = value;
}
return value;
}
}
private bool HasParameters() { // MDAC 65548
OleDbParameterCollection value = _parameters;
return (null != value) && (0 < value.Count); // VS 300569
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
ResDescriptionAttribute(Res.DbCommand_Transaction),
]
new public OleDbTransaction Transaction {
get {
// find the last non-zombied local transaction object, but not transactions
// that may have been started after the current local transaction
OleDbTransaction transaction = _transaction;
while ((null != transaction) && (null == transaction.Connection)) {
transaction = transaction.Parent;
_transaction = transaction;
}
return transaction;
}
set {
_transaction = value;
Bid.Trace(" %d#\n", ObjectID);
}
}
[
DefaultValue(System.Data.UpdateRowSource.Both),
ResCategoryAttribute(Res.DataCategory_Update),
ResDescriptionAttribute(Res.DbCommand_UpdatedRowSource),
]
override public UpdateRowSource UpdatedRowSource { // V1.2.3300, XXXCommand V1.0.5000
get {
return _updatedRowSource;
}
set {
switch(value) { // @perfnote: Enum.IsDefined
case UpdateRowSource.None:
case UpdateRowSource.OutputParameters:
case UpdateRowSource.FirstReturnedRecord:
case UpdateRowSource.Both:
_updatedRowSource = value;
break;
default:
throw ADP.InvalidUpdateRowSource(value);
}
}
}
// required interface, safe cast
private UnsafeNativeMethods.IAccessor IAccessor() {
Bid.Trace(" %d#, IAccessor\n", ObjectID);
Debug.Assert(null != _icommandText, "IAccessor: null ICommandText");
return (UnsafeNativeMethods.IAccessor) _icommandText;
}
// required interface, safe cast
internal UnsafeNativeMethods.ICommandProperties ICommandProperties() {
Bid.Trace(" %d#, ICommandProperties\n", ObjectID);
Debug.Assert(null != _icommandText, "ICommandProperties: null ICommandText");
return (UnsafeNativeMethods.ICommandProperties) _icommandText;
}
// optional interface, unsafe cast
private UnsafeNativeMethods.ICommandPrepare ICommandPrepare() {
Bid.Trace(" %d#, ICommandPrepare\n", ObjectID);
Debug.Assert(null != _icommandText, "ICommandPrepare: null ICommandText");
return (_icommandText as UnsafeNativeMethods.ICommandPrepare);
}
// optional interface, unsafe cast
private UnsafeNativeMethods.ICommandWithParameters ICommandWithParameters() {
Bid.Trace(" %d#, ICommandWithParameters\n", ObjectID);
Debug.Assert(null != _icommandText, "ICommandWithParameters: null ICommandText");
UnsafeNativeMethods.ICommandWithParameters value = (_icommandText as UnsafeNativeMethods.ICommandWithParameters);
if (null == value) {
throw ODB.NoProviderSupportForParameters(_connection.Provider, (Exception)null);
}
return value;
}
private void CreateAccessor() {
Debug.Assert(System.Data.CommandType.Text == CommandType || System.Data.CommandType.StoredProcedure == CommandType, "CreateAccessor: incorrect CommandType");
Debug.Assert(null == _dbBindings, "CreateAccessor: already has dbBindings");
Debug.Assert(HasParameters(), "CreateAccessor: unexpected, no parameter collection");
// do this first in-case the command doesn't support parameters
UnsafeNativeMethods.ICommandWithParameters commandWithParameters = ICommandWithParameters();
OleDbParameterCollection collection = _parameters;
OleDbParameter[] parameters = new OleDbParameter[collection.Count];
collection.CopyTo(parameters, 0);
// _dbBindings is used as a switch during ExecuteCommand, so don't set it until everything okay
Bindings bindings = new Bindings(parameters, collection.ChangeID);
for (int i = 0; i < parameters.Length; ++i) {
bindings.ForceRebind |= parameters[i].BindParameter(i, bindings);
}
bindings.AllocateForAccessor(null, 0, 0);
ApplyParameterBindings(commandWithParameters, bindings.BindInfo);
UnsafeNativeMethods.IAccessor iaccessor = IAccessor();
OleDbHResult hr = bindings.CreateAccessor(iaccessor, ODB.DBACCESSOR_PARAMETERDATA);
if (hr < 0) {
ProcessResults(hr);
}
_dbBindings = bindings;
}
private void ApplyParameterBindings(UnsafeNativeMethods.ICommandWithParameters commandWithParameters, tagDBPARAMBINDINFO[] bindInfo) {
IntPtr[] ordinals = new IntPtr[bindInfo.Length];
for (int i = 0; i < ordinals.Length; ++i) {
ordinals[i] = (IntPtr)(i+1);
}
Bid.Trace(" %d#\n", ObjectID);
OleDbHResult hr = commandWithParameters.SetParameterInfo((IntPtr)bindInfo.Length, ordinals, bindInfo);
Bid.Trace(" %08X{HRESULT}\n", hr);
if (hr < 0) {
ProcessResults(hr);
}
}
override public void Cancel() {
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#\n", ObjectID);
try {
unchecked { _changeID++; }
UnsafeNativeMethods.ICommandText icmdtxt = _icommandText;
if (null != icmdtxt) {
OleDbHResult hr = OleDbHResult.S_OK;
lock(icmdtxt) {
// lock the object to avoid race conditions between using the object and releasing the object
// after we acquire the lock, if the class has moved on don't actually call Cancel
if (icmdtxt == _icommandText) {
Bid.Trace(" %d#\n", ObjectID);
hr = icmdtxt.Cancel();
Bid.Trace(" %08X{HRESULT}\n", hr);
}
}
if (OleDbHResult.DB_E_CANTCANCEL != hr) {
// if the provider can't cancel the command - don't cancel the DataReader
this.canceling = true;
}
// since cancel is allowed to occur at anytime we can't check the connection status
// since if it returns as closed then the connection will close causing the reader to close
// and that would introduce the possilbility of one thread reading and one thread closing at the same time
ProcessResultsNoReset(hr); // MDAC 72667
}
else {
this.canceling = true;
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
public OleDbCommand Clone() {
OleDbCommand clone = new OleDbCommand(this);
Bid.Trace(" %d#, clone=%d#\n", ObjectID, clone.ObjectID);
return clone;
}
object ICloneable.Clone() {
return Clone();
}
// Connection.Close & Connection.Dispose(true) notification
internal void CloseCommandFromConnection(bool canceling) {
this.canceling = canceling; // MDAC 71435
CloseInternal();
_trackingForClose = false;
_transaction = null;
//GC.SuppressFinalize(this);
}
internal void CloseInternal() {
Debug.Assert(null != _connection, "no connection, CloseInternal");
CloseInternalParameters();
CloseInternalCommand();
}
// may be called from either
// OleDbDataReader.Close/Dispose
// via OleDbCommand.Dispose or OleDbConnection.Close
internal void CloseFromDataReader(Bindings bindings) {
if (null != bindings) {
if (canceling) {
bindings.Dispose();
Debug.Assert(_dbBindings != bindings, "bindings with two owners");
}
else {
bindings.ApplyOutputParameters();
ParameterBindings = bindings;
}
}
_hasDataReader = false;
}
private void CloseInternalCommand() {
unchecked { _changeID++; }
this.commandBehavior = CommandBehavior.Default;
_isPrepared = false;
UnsafeNativeMethods.ICommandText ict = Interlocked.Exchange(ref _icommandText, null);
if (null != ict) {
lock(ict) {
// lock the object to avoid race conditions between using the object and releasing the object
Marshal.ReleaseComObject(ict);
}
}
}
private void CloseInternalParameters() {
Debug.Assert(null != _connection, "no connection, CloseInternalParameters");
Bindings bindings = _dbBindings;
_dbBindings = null;
if (null != bindings) {
bindings.Dispose();
}
}
new public OleDbParameter CreateParameter() {
return new OleDbParameter();
}
override protected DbParameter CreateDbParameter() {
return CreateParameter();
}
override protected void Dispose(bool disposing) { // MDAC 65459
if (disposing) { // release mananged objects
// the DataReader takes ownership of the parameter Bindings
// this way they don't get destroyed when user calls OleDbCommand.Dispose
// when there is an open DataReader
unchecked { _changeID++; }
// in V1.0, V1.1 the Connection,Parameters,CommandText,Transaction where reset
ResetConnection();
_transaction = null;
_parameters = null;
CommandText = null;
}
// release unmanaged objects
base.Dispose(disposing); // notify base classes
}
new public OleDbDataReader ExecuteReader() {
return ExecuteReader(CommandBehavior.Default);
}
IDataReader IDbCommand.ExecuteReader() {
return ExecuteReader(CommandBehavior.Default);
}
new public OleDbDataReader ExecuteReader(CommandBehavior behavior) {
OleDbConnection.ExecutePermission.Demand();
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#, behavior=%d{ds.CommandBehavior}\n", ObjectID, (int)behavior);
try {
_executeQuery = true;
return ExecuteReaderInternal(behavior, ADP.ExecuteReader);
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
IDataReader IDbCommand.ExecuteReader(CommandBehavior behavior) {
return ExecuteReader(behavior);
}
override protected DbDataReader ExecuteDbDataReader(CommandBehavior behavior) {
return ExecuteReader(behavior);
}
private OleDbDataReader ExecuteReaderInternal(CommandBehavior behavior, string method) {
OleDbDataReader dataReader = null;
OleDbException nextResultsFailure = null;
int state = ODB.InternalStateClosed;
try {
ValidateConnectionAndTransaction(method);
if (0 != (CommandBehavior.SingleRow & behavior)) {
// CommandBehavior.SingleRow implies CommandBehavior.SingleResult
behavior |= CommandBehavior.SingleResult;
}
object executeResult;
int resultType;
switch(CommandType) {
case 0: // uninitialized CommandType.Text
case CommandType.Text:
case CommandType.StoredProcedure:
resultType = ExecuteCommand(behavior, out executeResult);
break;
case CommandType.TableDirect:
resultType = ExecuteTableDirect(behavior, out executeResult);
break;
default:
throw ADP.InvalidCommandType(CommandType);
}
if (_executeQuery) {
try {
dataReader = new OleDbDataReader(_connection, this, 0, this.commandBehavior);
switch(resultType) {
case ODB.ExecutedIMultipleResults:
dataReader.InitializeIMultipleResults(executeResult);
dataReader.NextResult();
break;
case ODB.ExecutedIRowset:
dataReader.InitializeIRowset(executeResult, ChapterHandle.DB_NULL_HCHAPTER, _recordsAffected);
dataReader.BuildMetaInfo();
dataReader.HasRowsRead();
break;
case ODB.ExecutedIRow:
dataReader.InitializeIRow(executeResult, _recordsAffected);
dataReader.BuildMetaInfo();
break;
case ODB.PrepareICommandText:
if (!_isPrepared) {
PrepareCommandText(2);
}
OleDbDataReader.GenerateSchemaTable(dataReader, _icommandText, behavior);
break;
default:
Debug.Assert(false, "ExecuteReaderInternal: unknown result type");
break;
}
executeResult = null;
_hasDataReader = true;
_connection.AddWeakReference(dataReader, OleDbReferenceCollection.DataReaderTag);
// command stays in the executing state until the connection
// has a datareader to track for it being closed
state = ODB.InternalStateOpen; // MDAC 72655
}
finally {
if (ODB.InternalStateOpen != state) {
this.canceling = true;
if (null != dataReader) {
((IDisposable) dataReader).Dispose();
dataReader = null;
}
}
}
Debug.Assert(null != dataReader, "ExecuteReader should never return a null DataReader");
}
else { // optimized code path for ExecuteNonQuery to not create a OleDbDataReader object
try {
if (ODB.ExecutedIMultipleResults == resultType) {
UnsafeNativeMethods.IMultipleResults multipleResults = (UnsafeNativeMethods.IMultipleResults) executeResult;
// may cause a Connection.ResetState which closes connection
nextResultsFailure = OleDbDataReader.NextResults(multipleResults, _connection, this, out _recordsAffected);
}
}
finally {
try {
if (null != executeResult) {
Marshal.ReleaseComObject(executeResult);
executeResult = null;
}
CloseFromDataReader(ParameterBindings);
}
catch(Exception e) {
//
if (!ADP.IsCatchableExceptionType(e)) {
throw;
}
if (null != nextResultsFailure) {
nextResultsFailure = new OleDbException(nextResultsFailure, e);
}
else {
throw;
}
}
}
}
}
finally { // finally clear executing state
try {
if ((null == dataReader) && (ODB.InternalStateOpen != state)) { // MDAC 67218
ParameterCleanup();
}
}
catch(Exception e) {
//
if (!ADP.IsCatchableExceptionType(e)) {
throw;
}
if (null != nextResultsFailure) {
nextResultsFailure = new OleDbException(nextResultsFailure, e);
}
else {
throw;
}
}
if (null != nextResultsFailure) {
throw nextResultsFailure;
}
}
return dataReader;
}
private int ExecuteCommand(CommandBehavior behavior, out object executeResult) {
if (InitializeCommand(behavior, false)) {
if (0 != (CommandBehavior.SchemaOnly & this.commandBehavior)) {
executeResult = null;
return ODB.PrepareICommandText;
}
return ExecuteCommandText(out executeResult);
}
return ExecuteTableDirect(behavior, out executeResult); // MDAC 57856
}
// dbindings handle can't be freed until the output parameters
// have been filled in which occurs after the last rowset is released
// dbbindings.FreeDataHandle occurs in Cloe
private int ExecuteCommandText(out object executeResult) {
int retcode;
tagDBPARAMS dbParams = null;
RowBinding rowbinding = null;
Bindings bindings = ParameterBindings;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
if (null != bindings) { // parameters may be suppressed
rowbinding = bindings.RowBinding();
rowbinding.DangerousAddRef(ref mustRelease);
// bindings can't be released until after last rowset is released
// that is when output parameters are populated
// initialize the input parameters to the input databuffer
bindings.ApplyInputParameters();
dbParams = new tagDBPARAMS();
dbParams.pData = rowbinding.DangerousGetDataPtr();
dbParams.cParamSets = 1;
dbParams.hAccessor = rowbinding.DangerousGetAccessorHandle();
}
if ((0 == (CommandBehavior.SingleResult & this.commandBehavior)) && _connection.SupportMultipleResults()) {
retcode = ExecuteCommandTextForMultpleResults(dbParams, out executeResult);
}
else if (0 == (CommandBehavior.SingleRow & this.commandBehavior) || !_executeQuery) {
retcode = ExecuteCommandTextForSingleResult(dbParams, out executeResult);
}
else {
retcode = ExecuteCommandTextForSingleRow(dbParams, out executeResult);
}
}
finally {
if (mustRelease) {
rowbinding.DangerousRelease();
}
}
return retcode;
}
private int ExecuteCommandTextForMultpleResults(tagDBPARAMS dbParams, out object executeResult) {
Debug.Assert(0 == (CommandBehavior.SingleRow & this.commandBehavior), "SingleRow implies SingleResult");
OleDbHResult hr;
Bid.Trace(" %d#, IID_IMultipleResults\n", ObjectID);
hr = _icommandText.Execute(ADP.PtrZero, ref ODB.IID_IMultipleResults, dbParams, out _recordsAffected, out executeResult);
Bid.Trace(" %08X{HRESULT}, RecordsAffected=%Id\n", hr, _recordsAffected);
if (OleDbHResult.E_NOINTERFACE != hr) {
ExecuteCommandTextErrorHandling(hr);
return ODB.ExecutedIMultipleResults;
}
SafeNativeMethods.Wrapper.ClearErrorInfo();
return ExecuteCommandTextForSingleResult(dbParams, out executeResult);
}
private int ExecuteCommandTextForSingleResult(tagDBPARAMS dbParams, out object executeResult) {
OleDbHResult hr;
// MDAC 64465 (Microsoft.Jet.OLEDB.4.0 returns 0 for recordsAffected instead of -1)
if (_executeQuery) {
Bid.Trace(" %d#, IID_IRowset\n", ObjectID);
hr = _icommandText.Execute(ADP.PtrZero, ref ODB.IID_IRowset, dbParams, out _recordsAffected, out executeResult);
Bid.Trace(" %08X{HRESULT}, RecordsAffected=%Id\n", hr, _recordsAffected);
}
else {
Bid.Trace(" %d#, IID_NULL\n", ObjectID);
hr = _icommandText.Execute(ADP.PtrZero, ref ODB.IID_NULL, dbParams, out _recordsAffected, out executeResult);
Bid.Trace(" %08X{HRESULT}, RecordsAffected=%Id\n", hr, _recordsAffected);
}
ExecuteCommandTextErrorHandling(hr);
return ODB.ExecutedIRowset;
}
private int ExecuteCommandTextForSingleRow(tagDBPARAMS dbParams, out object executeResult) {
Debug.Assert(_executeQuery, "ExecuteNonQuery should always use ExecuteCommandTextForSingleResult");
if (_connection.SupportIRow(this)) {
OleDbHResult hr;
Bid.Trace(" %d#, IID_IRow\n", ObjectID);
hr = _icommandText.Execute(ADP.PtrZero, ref ODB.IID_IRow, dbParams, out _recordsAffected, out executeResult);
Bid.Trace(" %08X{HRESULT}, RecordsAffected=%Id\n", hr, _recordsAffected);
if (OleDbHResult.DB_E_NOTFOUND == hr) { // MDAC 76110
SafeNativeMethods.Wrapper.ClearErrorInfo();
return ODB.ExecutedIRow;
}
else if (OleDbHResult.E_NOINTERFACE != hr) {
ExecuteCommandTextErrorHandling(hr);
return ODB.ExecutedIRow;
}
}
SafeNativeMethods.Wrapper.ClearErrorInfo();
return ExecuteCommandTextForSingleResult(dbParams, out executeResult);
}
private void ExecuteCommandTextErrorHandling(OleDbHResult hr) {
Exception e = OleDbConnection.ProcessResults(hr, _connection, this);
if (null != e) {
e = ExecuteCommandTextSpecialErrorHandling(hr, e);
throw e;
}
}
private Exception ExecuteCommandTextSpecialErrorHandling(OleDbHResult hr, Exception e) {
if (((OleDbHResult.DB_E_ERRORSOCCURRED == hr) || (OleDbHResult.DB_E_BADBINDINFO == hr)) && (null != _dbBindings)) { // MDAC 66026, 67039
//
// this code exist to try for a better user error message by post-morten detection
// of invalid parameter types being passed to a provider that doesn't understand
// the user specified parameter OleDbType
Debug.Assert(null != e, "missing inner exception");
StringBuilder builder = new StringBuilder();
ParameterBindings.ParameterStatus(builder);
e = ODB.CommandParameterStatus(builder.ToString(), e);
}
return e;
}
override public int ExecuteNonQuery() {
OleDbConnection.ExecutePermission.Demand();
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#\n", ObjectID);
try {
_executeQuery = false;
ExecuteReaderInternal(CommandBehavior.Default, ADP.ExecuteNonQuery);
return ADP.IntPtrToInt32(_recordsAffected);
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
override public object ExecuteScalar() {
OleDbConnection.ExecutePermission.Demand();
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#\n", ObjectID);
try {
object value = null;
_executeQuery = true;
using(OleDbDataReader reader = ExecuteReaderInternal(CommandBehavior.Default, ADP.ExecuteScalar)) {
if (reader.Read() && (0 < reader.FieldCount)) {
value = reader.GetValue(0);
}
}
return value;
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
private int ExecuteTableDirect(CommandBehavior behavior, out object executeResult) {
this.commandBehavior = behavior;
executeResult = null;
OleDbHResult hr = OleDbHResult.S_OK;
StringMemHandle sptr = null;
bool mustReleaseStringHandle = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
sptr = new StringMemHandle(ExpandCommandText());
sptr.DangerousAddRef(ref mustReleaseStringHandle);
if (mustReleaseStringHandle) {
tagDBID tableID = new tagDBID();
tableID.uGuid = Guid.Empty;
tableID.eKind = ODB.DBKIND_NAME;
tableID.ulPropid = sptr.DangerousGetHandle();
using(IOpenRowsetWrapper iopenRowset = _connection.IOpenRowset()) {
using(DBPropSet propSet = CommandPropertySets()) {
if (null != propSet) {
// MDAC 65279
Bid.Trace(" %d#, IID_IRowset\n", ObjectID);
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
propSet.DangerousAddRef(ref mustRelease);
hr = iopenRowset.Value.OpenRowset(ADP.PtrZero, tableID, ADP.PtrZero, ref ODB.IID_IRowset, propSet.PropertySetCount, propSet.DangerousGetHandle(), out executeResult);
}
finally {
if (mustRelease) {
propSet.DangerousRelease();
}
}
Bid.Trace(" %08X{HRESULT}", hr);
if (OleDbHResult.DB_E_ERRORSOCCURRED == hr) {
Bid.Trace(" %d#, IID_IRowset\n", ObjectID);
hr = iopenRowset.Value.OpenRowset(ADP.PtrZero, tableID, ADP.PtrZero, ref ODB.IID_IRowset, 0, IntPtr.Zero, out executeResult);
Bid.Trace(" %08X{HRESULT}", hr);
}
}
else {
Bid.Trace(" %d#, IID_IRowset\n", ObjectID);
hr = iopenRowset.Value.OpenRowset(ADP.PtrZero, tableID, ADP.PtrZero, ref ODB.IID_IRowset, 0, IntPtr.Zero, out executeResult);
Bid.Trace(" %08X{HRESULT}", hr);
}
}
}
}
}
finally {
if (mustReleaseStringHandle) {
sptr.DangerousRelease();
}
}
ProcessResults(hr);
_recordsAffected = ADP.RecordsUnaffected;
return ODB.ExecutedIRowset;
}
private string ExpandCommandText() {
string cmdtxt = CommandText;
if (ADP.IsEmpty(cmdtxt)) {
return ADP.StrEmpty;
}
CommandType cmdtype = CommandType;
switch(cmdtype) {
case System.Data.CommandType.Text:
// do nothing, already expanded by user
return cmdtxt;
case System.Data.CommandType.StoredProcedure:
// { ? = CALL SPROC (? ?) }, { ? = CALL SPROC }, { CALL SPRC (? ?) }, { CALL SPROC }
return ExpandStoredProcedureToText(cmdtxt);
case System.Data.CommandType.TableDirect:
// @devnote: Provider=Jolt4.0 doesn't like quoted table names, SQOLEDB requires them
// Providers should not require table names to be quoted and should guarantee that
// unquoted table names correctly open the specified table, even if the table name
// contains special characters, as long as the table can be unambiguously identified
// without quoting.
return cmdtxt;
default:
throw ADP.InvalidCommandType(cmdtype);
}
}
private string ExpandOdbcMaximumToText(string sproctext, int parameterCount) {
StringBuilder builder = new StringBuilder();
if ((0 < parameterCount) && (ParameterDirection.ReturnValue == Parameters[0].Direction)) {
parameterCount--;
builder.Append("{ ? = CALL ");
}
else {
builder.Append("{ CALL ");
}
builder.Append(sproctext); // WebData 95634
switch(parameterCount) {
case 0:
builder.Append(" }");
break;
case 1:
builder.Append("( ? ) }");
break;
default:
builder.Append("( ?, ?");
for (int i = 2; i < parameterCount; ++i) {
builder.Append(", ?");
}
builder.Append(" ) }");
break;
}
return builder.ToString();
}
private string ExpandOdbcMinimumToText(string sproctext, int parameterCount) {
//if ((0 < parameterCount) && (ParameterDirection.ReturnValue == Parameters[0].Direction)) {
// Debug.Assert("doesn't support ReturnValue parameters");
//}
StringBuilder builder = new StringBuilder();
builder.Append("exec ");
builder.Append(sproctext);
if (0 < parameterCount) {
builder.Append(" ?");
for(int i = 1; i < parameterCount; ++i) {
builder.Append(", ?");
}
}
return builder.ToString();
}
private string ExpandStoredProcedureToText(string sproctext) {
Debug.Assert(null != _connection, "ExpandStoredProcedureToText: null Connection");
int parameterCount = (null != _parameters) ? _parameters.Count : 0;
if (0 == (ODB.DBPROPVAL_SQL_ODBC_MINIMUM & _connection.SqlSupport())) {
return ExpandOdbcMinimumToText(sproctext, parameterCount);
}
return ExpandOdbcMaximumToText(sproctext, parameterCount);
}
private void ParameterCleanup() {
Bindings bindings = ParameterBindings;
if (null != bindings) {
bindings.CleanupBindings();
}
}
private bool InitializeCommand(CommandBehavior behavior, bool throwifnotsupported) {
Debug.Assert(null != _connection, "InitializeCommand: null OleDbConnection");
int changeid = _changeID;
if ((0 != (CommandBehavior.KeyInfo & (this.commandBehavior ^ behavior))) || (_lastChangeID != changeid)) {
CloseInternalParameters(); // could optimize out
CloseInternalCommand();
}
this.commandBehavior = behavior;
changeid = _changeID;
if (!PropertiesOnCommand(false)) {
return false; // MDAC 57856
}
if ((null != _dbBindings) && _dbBindings.AreParameterBindingsInvalid(_parameters)) {
CloseInternalParameters();
}
// if we already having bindings - don't create the accessor
// if _parameters is null - no parameters exist - don't create the collection
// do we actually have parameters since the collection exists
if ((null == _dbBindings) && HasParameters()) {
// if we setup the parameters before setting cmdtxt then named parameters can happen
CreateAccessor();
}
if (_lastChangeID != changeid) {
OleDbHResult hr;
String commandText = ExpandCommandText();
if (Bid.TraceOn) {
Bid.Trace(" %d#, DBGUID_DEFAULT, CommandText='", ObjectID);
Bid.PutStr(commandText); // Use PutStr to write out entire string
Bid.Trace("'\n");
}
hr = _icommandText.SetCommandText(ref ODB.DBGUID_DEFAULT, commandText);
Bid.Trace(" %08X{HRESULT}\n", hr);
if (hr < 0) {
ProcessResults(hr);
}
}
_lastChangeID = changeid;
return true;
}
private void PropertyChanging() {
unchecked { _changeID++; }
}
override public void Prepare() {
OleDbConnection.ExecutePermission.Demand();
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#\n", ObjectID);
try {
if (CommandType.TableDirect != CommandType) { // MDAC 70946, 71194
ValidateConnectionAndTransaction(ADP.Prepare);
_isPrepared = false;
if (CommandType.TableDirect != CommandType) {
InitializeCommand(0, true);
PrepareCommandText(1);
}
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
private void PrepareCommandText(int expectedExecutionCount) {
OleDbParameterCollection parameters = _parameters;
if (null != parameters) {
foreach(OleDbParameter parameter in parameters) {
if (parameter.IsParameterComputed()) {
// @devnote: use IsParameterComputed which is called in the normal case
// only to call Prepare to throw the specialized error message
// reducing the overall number of methods to actually jit
parameter.Prepare(this); // MDAC 70232
}
}
}
UnsafeNativeMethods.ICommandPrepare icommandPrepare = ICommandPrepare();
if (null != icommandPrepare) {
OleDbHResult hr;
Bid.Trace(" %d#, expectedExecutionCount=%d\n", ObjectID, expectedExecutionCount);
hr = icommandPrepare.Prepare(expectedExecutionCount);
Bid.Trace(" %08X{HRESULT}\n", hr);
ProcessResults(hr);
}
// don't recompute bindings on prepared statements
_isPrepared = true;
}
private void ProcessResults(OleDbHResult hr) {
Exception e = OleDbConnection.ProcessResults(hr, _connection, this);
if (null != e) { throw e; }
}
private void ProcessResultsNoReset(OleDbHResult hr) {
Exception e = OleDbConnection.ProcessResults(hr, null, this);
if (null != e) { throw e; }
}
internal object GetPropertyValue(Guid propertySet, int propertyID) {
if (null != _icommandText) {
OleDbHResult hr;
tagDBPROP[] dbprops;
UnsafeNativeMethods.ICommandProperties icommandProperties = ICommandProperties();
using(PropertyIDSet propidset = new PropertyIDSet(propertySet, propertyID)) {
using(DBPropSet propset = new DBPropSet(icommandProperties, propidset, out hr)) {
if (hr < 0) {
SafeNativeMethods.Wrapper.ClearErrorInfo();
}
dbprops = propset.GetPropertySet(0, out propertySet);
}
}
if (OleDbPropertyStatus.Ok == dbprops[0].dwStatus) {
return dbprops[0].vValue;
}
return dbprops[0].dwStatus;
}
return OleDbPropertyStatus.NotSupported;
}
private bool PropertiesOnCommand(bool throwNotSupported) {
if (null != _icommandText) {
return true;
}
Debug.Assert(!_isPrepared, "null command isPrepared");
OleDbConnection connection = _connection;
if (null == connection) {
connection.CheckStateOpen(ODB.Properties);
}
if (!_trackingForClose) {
_trackingForClose = true;
connection.AddWeakReference(this, OleDbReferenceCollection.CommandTag);
}
_icommandText = connection.ICommandText();
if (null == _icommandText) {
if (throwNotSupported || HasParameters()) {
throw ODB.CommandTextNotSupported(connection.Provider, null);
}
return false; // MDAC 57856
}
using(DBPropSet propSet = CommandPropertySets()) {
if (null != propSet) {
UnsafeNativeMethods.ICommandProperties icommandProperties = ICommandProperties();
Bid.Trace(" %d#\n", ObjectID);
OleDbHResult hr = icommandProperties.SetProperties(propSet.PropertySetCount, propSet);
Bid.Trace(" %08X{HRESULT}\n", hr);
if (hr < 0) {
SafeNativeMethods.Wrapper.ClearErrorInfo();
}
}
}
return true;
}
private DBPropSet CommandPropertySets() {
DBPropSet propSet = null;
bool keyInfo = (0 != (CommandBehavior.KeyInfo & this.commandBehavior));
// always set the CommandTimeout value?
int count = (_executeQuery ? (keyInfo ? 4 : 2) : 1);
if (0 < count) {
propSet = new DBPropSet(1);
tagDBPROP[] dbprops = new tagDBPROP[count];
dbprops[0] = new tagDBPROP(ODB.DBPROP_COMMANDTIMEOUT, false, CommandTimeout);
if (_executeQuery) {
// 'Microsoft.Jet.OLEDB.4.0' default is DBPROPVAL_AO_SEQUENTIAL
dbprops[1] = new tagDBPROP(ODB.DBPROP_ACCESSORDER, false, ODB.DBPROPVAL_AO_RANDOM); // MDAC 73030
if (keyInfo) {
// 'Unique Rows' property required for SQLOLEDB to retrieve things like 'BaseTableName'
dbprops[2] = new tagDBPROP(ODB.DBPROP_UNIQUEROWS, false, keyInfo);
// otherwise 'Microsoft.Jet.OLEDB.4.0' doesn't support IColumnsRowset
dbprops[3] = new tagDBPROP(ODB.DBPROP_IColumnsRowset, false, true);
}
}
propSet.SetPropertySet(0, OleDbPropertySetGuid.Rowset, dbprops);
}
return propSet;
}
internal Bindings TakeBindingOwnerShip() {
Bindings bindings = _dbBindings;
_dbBindings = null;
return bindings;
}
private void ValidateConnection(string method) {
if (null == _connection) {
throw ADP.ConnectionRequired(method);
}
_connection.CheckStateOpen(method);
// user attempting to execute the command while the first dataReader hasn't returned
// use the connection reference collection to see if the dataReader referencing this
// command has been garbage collected or not.
if (_hasDataReader) {
if (_connection.HasLiveReader(this)) {
throw ADP.OpenReaderExists();
}
_hasDataReader = false;
}
}
private void ValidateConnectionAndTransaction(string method) {
ValidateConnection(method);
_transaction = _connection.ValidateTransaction(Transaction, method);
this.canceling = false;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
namespace System.Data.OleDb {
using System;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.ProviderBase;
using System.Diagnostics;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Text;
[
DefaultEvent("RecordsAffected"),
ToolboxItem(true),
Designer("Microsoft.VSDesigner.Data.VS.OleDbCommandDesigner, " + AssemblyRef.MicrosoftVSDesigner)
]
#if WINFSInternalOnly
internal
#else
public
#endif
sealed class OleDbCommand : DbCommand, ICloneable, IDbCommand {
// command data
private string _commandText;
private CommandType _commandType;
private int _commandTimeout = ADP.DefaultCommandTimeout;
private UpdateRowSource _updatedRowSource = UpdateRowSource.Both;
private bool _designTimeInvisible;
private OleDbConnection _connection;
private OleDbTransaction _transaction;
private static int _objectTypeCount; // Bid counter
internal readonly int ObjectID = System.Threading.Interlocked.Increment(ref _objectTypeCount);
private OleDbParameterCollection _parameters;
// native information
private UnsafeNativeMethods.ICommandText _icommandText;
// if executing with a different CommandBehavior.KeyInfo behavior
// original ICommandText must be released and a new ICommandText generated
private CommandBehavior commandBehavior;
private Bindings _dbBindings;
internal bool canceling; // MDAC 68964
private bool _isPrepared;
private bool _executeQuery;
private bool _trackingForClose;
private bool _hasDataReader;
private IntPtr _recordsAffected;
private int _changeID;
private int _lastChangeID;
public OleDbCommand() : base() {
GC.SuppressFinalize(this);
}
public OleDbCommand(string cmdText) : this() {
CommandText = cmdText;
}
public OleDbCommand(string cmdText, OleDbConnection connection) : this() {
CommandText = cmdText;
Connection = connection;
}
public OleDbCommand(string cmdText, OleDbConnection connection, OleDbTransaction transaction) : this() {
CommandText = cmdText;
Connection = connection;
Transaction = transaction;
}
private OleDbCommand(OleDbCommand from) : this() { // Clone
CommandText = from.CommandText;
CommandTimeout = from.CommandTimeout;
CommandType = from.CommandType;
Connection = from.Connection;
DesignTimeVisible = from.DesignTimeVisible;
UpdatedRowSource = from.UpdatedRowSource;
Transaction = from.Transaction;
OleDbParameterCollection parameters = Parameters;
foreach(object parameter in from.Parameters) {
parameters.Add((parameter is ICloneable) ? (parameter as ICloneable).Clone() : parameter);
}
}
private Bindings ParameterBindings {
get {
return _dbBindings;
}
set {
Bindings bindings = _dbBindings;
_dbBindings = value;
if ((null != bindings) && (value != bindings)) {
bindings.Dispose();
}
}
}
[
DefaultValue(""),
Editor("Microsoft.VSDesigner.Data.ADO.Design.OleDbCommandTextEditor, " + AssemblyRef.MicrosoftVSDesigner, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing),
RefreshProperties(RefreshProperties.All), // MDAC 67707
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbCommand_CommandText),
]
override public string CommandText {
get {
string value = _commandText;
return ((null != value) ? value : ADP.StrEmpty);
}
set {
if (Bid.TraceOn) {
Bid.Trace(" %d#, '", ObjectID);
Bid.PutStr(value); // Use PutStr to write out entire string
Bid.Trace("'\n");
}
if (0 != ADP.SrcCompare(_commandText, value)) {
PropertyChanging();
_commandText = value;
}
}
}
[
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbCommand_CommandTimeout),
]
override public int CommandTimeout { // V1.2.3300, XXXCommand V1.0.5000
get {
return _commandTimeout;
}
set {
Bid.Trace(" %d#, %d\n", ObjectID, value);
if (value < 0) {
throw ADP.InvalidCommandTimeout(value);
}
if (value != _commandTimeout) {
PropertyChanging();
_commandTimeout = value;
}
}
}
public void ResetCommandTimeout() { // V1.2.3300
if (ADP.DefaultCommandTimeout != _commandTimeout) {
PropertyChanging();
_commandTimeout = ADP.DefaultCommandTimeout;
}
}
private bool ShouldSerializeCommandTimeout() { // V1.2.3300
return (ADP.DefaultCommandTimeout != _commandTimeout);
}
[
DefaultValue(System.Data.CommandType.Text),
RefreshProperties(RefreshProperties.All),
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbCommand_CommandType),
]
override public CommandType CommandType {
get {
CommandType cmdType = _commandType;
return ((0 != cmdType) ? cmdType : CommandType.Text);
}
set {
switch(value) { // @perfnote: Enum.IsDefined
case CommandType.Text:
case CommandType.StoredProcedure:
case CommandType.TableDirect:
PropertyChanging();
_commandType = value;
break;
default:
throw ADP.InvalidCommandType(value);
}
}
}
[
DefaultValue(null),
Editor("Microsoft.VSDesigner.Data.Design.DbConnectionEditor, " + AssemblyRef.MicrosoftVSDesigner, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing),
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbCommand_Connection),
]
new public OleDbConnection Connection {
get {
return _connection;
}
set {
OleDbConnection connection = _connection;
if (value != connection) {
PropertyChanging();
ResetConnection();
_connection = value;
Bid.Trace(" %d#\n", ObjectID);
if (null != value) {
_transaction = OleDbTransaction.TransactionUpdate(_transaction); // MDAC 63226
}
}
}
}
private void ResetConnection() {
OleDbConnection connection = _connection;
if (null != connection) {
PropertyChanging();
CloseInternal();
if (_trackingForClose) {
connection.RemoveWeakReference(this);
_trackingForClose = false;
}
}
_connection = null;
}
override protected DbConnection DbConnection { // V1.2.3300
get {
return Connection;
}
set {
Connection = (OleDbConnection)value;
}
}
override protected DbParameterCollection DbParameterCollection { // V1.2.3300
get {
return Parameters;
}
}
override protected DbTransaction DbTransaction { // V1.2.3300
get {
return Transaction;
}
set {
Transaction = (OleDbTransaction)value;
}
}
// @devnote: By default, the cmd object is visible on the design surface (i.e. VS7 Server Tray)
// to limit the number of components that clutter the design surface,
// when the DataAdapter design wizard generates the insert/update/delete commands it will
// set the DesignTimeVisible property to false so that cmds won't appear as individual objects
[
DefaultValue(true),
DesignOnly(true),
Browsable(false),
EditorBrowsableAttribute(EditorBrowsableState.Never),
]
public override bool DesignTimeVisible { // V1.2.3300, XXXCommand V1.0.5000
get {
return !_designTimeInvisible;
}
set {
_designTimeInvisible = !value;
TypeDescriptor.Refresh(this); // VS7 208845
}
}
[
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbCommand_Parameters),
]
new public OleDbParameterCollection Parameters {
get {
OleDbParameterCollection value = _parameters;
if (null == value) {
// delay the creation of the OleDbParameterCollection
// until user actually uses the Parameters property
value = new OleDbParameterCollection();
_parameters = value;
}
return value;
}
}
private bool HasParameters() { // MDAC 65548
OleDbParameterCollection value = _parameters;
return (null != value) && (0 < value.Count); // VS 300569
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
ResDescriptionAttribute(Res.DbCommand_Transaction),
]
new public OleDbTransaction Transaction {
get {
// find the last non-zombied local transaction object, but not transactions
// that may have been started after the current local transaction
OleDbTransaction transaction = _transaction;
while ((null != transaction) && (null == transaction.Connection)) {
transaction = transaction.Parent;
_transaction = transaction;
}
return transaction;
}
set {
_transaction = value;
Bid.Trace(" %d#\n", ObjectID);
}
}
[
DefaultValue(System.Data.UpdateRowSource.Both),
ResCategoryAttribute(Res.DataCategory_Update),
ResDescriptionAttribute(Res.DbCommand_UpdatedRowSource),
]
override public UpdateRowSource UpdatedRowSource { // V1.2.3300, XXXCommand V1.0.5000
get {
return _updatedRowSource;
}
set {
switch(value) { // @perfnote: Enum.IsDefined
case UpdateRowSource.None:
case UpdateRowSource.OutputParameters:
case UpdateRowSource.FirstReturnedRecord:
case UpdateRowSource.Both:
_updatedRowSource = value;
break;
default:
throw ADP.InvalidUpdateRowSource(value);
}
}
}
// required interface, safe cast
private UnsafeNativeMethods.IAccessor IAccessor() {
Bid.Trace(" %d#, IAccessor\n", ObjectID);
Debug.Assert(null != _icommandText, "IAccessor: null ICommandText");
return (UnsafeNativeMethods.IAccessor) _icommandText;
}
// required interface, safe cast
internal UnsafeNativeMethods.ICommandProperties ICommandProperties() {
Bid.Trace(" %d#, ICommandProperties\n", ObjectID);
Debug.Assert(null != _icommandText, "ICommandProperties: null ICommandText");
return (UnsafeNativeMethods.ICommandProperties) _icommandText;
}
// optional interface, unsafe cast
private UnsafeNativeMethods.ICommandPrepare ICommandPrepare() {
Bid.Trace(" %d#, ICommandPrepare\n", ObjectID);
Debug.Assert(null != _icommandText, "ICommandPrepare: null ICommandText");
return (_icommandText as UnsafeNativeMethods.ICommandPrepare);
}
// optional interface, unsafe cast
private UnsafeNativeMethods.ICommandWithParameters ICommandWithParameters() {
Bid.Trace(" %d#, ICommandWithParameters\n", ObjectID);
Debug.Assert(null != _icommandText, "ICommandWithParameters: null ICommandText");
UnsafeNativeMethods.ICommandWithParameters value = (_icommandText as UnsafeNativeMethods.ICommandWithParameters);
if (null == value) {
throw ODB.NoProviderSupportForParameters(_connection.Provider, (Exception)null);
}
return value;
}
private void CreateAccessor() {
Debug.Assert(System.Data.CommandType.Text == CommandType || System.Data.CommandType.StoredProcedure == CommandType, "CreateAccessor: incorrect CommandType");
Debug.Assert(null == _dbBindings, "CreateAccessor: already has dbBindings");
Debug.Assert(HasParameters(), "CreateAccessor: unexpected, no parameter collection");
// do this first in-case the command doesn't support parameters
UnsafeNativeMethods.ICommandWithParameters commandWithParameters = ICommandWithParameters();
OleDbParameterCollection collection = _parameters;
OleDbParameter[] parameters = new OleDbParameter[collection.Count];
collection.CopyTo(parameters, 0);
// _dbBindings is used as a switch during ExecuteCommand, so don't set it until everything okay
Bindings bindings = new Bindings(parameters, collection.ChangeID);
for (int i = 0; i < parameters.Length; ++i) {
bindings.ForceRebind |= parameters[i].BindParameter(i, bindings);
}
bindings.AllocateForAccessor(null, 0, 0);
ApplyParameterBindings(commandWithParameters, bindings.BindInfo);
UnsafeNativeMethods.IAccessor iaccessor = IAccessor();
OleDbHResult hr = bindings.CreateAccessor(iaccessor, ODB.DBACCESSOR_PARAMETERDATA);
if (hr < 0) {
ProcessResults(hr);
}
_dbBindings = bindings;
}
private void ApplyParameterBindings(UnsafeNativeMethods.ICommandWithParameters commandWithParameters, tagDBPARAMBINDINFO[] bindInfo) {
IntPtr[] ordinals = new IntPtr[bindInfo.Length];
for (int i = 0; i < ordinals.Length; ++i) {
ordinals[i] = (IntPtr)(i+1);
}
Bid.Trace(" %d#\n", ObjectID);
OleDbHResult hr = commandWithParameters.SetParameterInfo((IntPtr)bindInfo.Length, ordinals, bindInfo);
Bid.Trace(" %08X{HRESULT}\n", hr);
if (hr < 0) {
ProcessResults(hr);
}
}
override public void Cancel() {
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#\n", ObjectID);
try {
unchecked { _changeID++; }
UnsafeNativeMethods.ICommandText icmdtxt = _icommandText;
if (null != icmdtxt) {
OleDbHResult hr = OleDbHResult.S_OK;
lock(icmdtxt) {
// lock the object to avoid race conditions between using the object and releasing the object
// after we acquire the lock, if the class has moved on don't actually call Cancel
if (icmdtxt == _icommandText) {
Bid.Trace(" %d#\n", ObjectID);
hr = icmdtxt.Cancel();
Bid.Trace(" %08X{HRESULT}\n", hr);
}
}
if (OleDbHResult.DB_E_CANTCANCEL != hr) {
// if the provider can't cancel the command - don't cancel the DataReader
this.canceling = true;
}
// since cancel is allowed to occur at anytime we can't check the connection status
// since if it returns as closed then the connection will close causing the reader to close
// and that would introduce the possilbility of one thread reading and one thread closing at the same time
ProcessResultsNoReset(hr); // MDAC 72667
}
else {
this.canceling = true;
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
public OleDbCommand Clone() {
OleDbCommand clone = new OleDbCommand(this);
Bid.Trace(" %d#, clone=%d#\n", ObjectID, clone.ObjectID);
return clone;
}
object ICloneable.Clone() {
return Clone();
}
// Connection.Close & Connection.Dispose(true) notification
internal void CloseCommandFromConnection(bool canceling) {
this.canceling = canceling; // MDAC 71435
CloseInternal();
_trackingForClose = false;
_transaction = null;
//GC.SuppressFinalize(this);
}
internal void CloseInternal() {
Debug.Assert(null != _connection, "no connection, CloseInternal");
CloseInternalParameters();
CloseInternalCommand();
}
// may be called from either
// OleDbDataReader.Close/Dispose
// via OleDbCommand.Dispose or OleDbConnection.Close
internal void CloseFromDataReader(Bindings bindings) {
if (null != bindings) {
if (canceling) {
bindings.Dispose();
Debug.Assert(_dbBindings != bindings, "bindings with two owners");
}
else {
bindings.ApplyOutputParameters();
ParameterBindings = bindings;
}
}
_hasDataReader = false;
}
private void CloseInternalCommand() {
unchecked { _changeID++; }
this.commandBehavior = CommandBehavior.Default;
_isPrepared = false;
UnsafeNativeMethods.ICommandText ict = Interlocked.Exchange(ref _icommandText, null);
if (null != ict) {
lock(ict) {
// lock the object to avoid race conditions between using the object and releasing the object
Marshal.ReleaseComObject(ict);
}
}
}
private void CloseInternalParameters() {
Debug.Assert(null != _connection, "no connection, CloseInternalParameters");
Bindings bindings = _dbBindings;
_dbBindings = null;
if (null != bindings) {
bindings.Dispose();
}
}
new public OleDbParameter CreateParameter() {
return new OleDbParameter();
}
override protected DbParameter CreateDbParameter() {
return CreateParameter();
}
override protected void Dispose(bool disposing) { // MDAC 65459
if (disposing) { // release mananged objects
// the DataReader takes ownership of the parameter Bindings
// this way they don't get destroyed when user calls OleDbCommand.Dispose
// when there is an open DataReader
unchecked { _changeID++; }
// in V1.0, V1.1 the Connection,Parameters,CommandText,Transaction where reset
ResetConnection();
_transaction = null;
_parameters = null;
CommandText = null;
}
// release unmanaged objects
base.Dispose(disposing); // notify base classes
}
new public OleDbDataReader ExecuteReader() {
return ExecuteReader(CommandBehavior.Default);
}
IDataReader IDbCommand.ExecuteReader() {
return ExecuteReader(CommandBehavior.Default);
}
new public OleDbDataReader ExecuteReader(CommandBehavior behavior) {
OleDbConnection.ExecutePermission.Demand();
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#, behavior=%d{ds.CommandBehavior}\n", ObjectID, (int)behavior);
try {
_executeQuery = true;
return ExecuteReaderInternal(behavior, ADP.ExecuteReader);
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
IDataReader IDbCommand.ExecuteReader(CommandBehavior behavior) {
return ExecuteReader(behavior);
}
override protected DbDataReader ExecuteDbDataReader(CommandBehavior behavior) {
return ExecuteReader(behavior);
}
private OleDbDataReader ExecuteReaderInternal(CommandBehavior behavior, string method) {
OleDbDataReader dataReader = null;
OleDbException nextResultsFailure = null;
int state = ODB.InternalStateClosed;
try {
ValidateConnectionAndTransaction(method);
if (0 != (CommandBehavior.SingleRow & behavior)) {
// CommandBehavior.SingleRow implies CommandBehavior.SingleResult
behavior |= CommandBehavior.SingleResult;
}
object executeResult;
int resultType;
switch(CommandType) {
case 0: // uninitialized CommandType.Text
case CommandType.Text:
case CommandType.StoredProcedure:
resultType = ExecuteCommand(behavior, out executeResult);
break;
case CommandType.TableDirect:
resultType = ExecuteTableDirect(behavior, out executeResult);
break;
default:
throw ADP.InvalidCommandType(CommandType);
}
if (_executeQuery) {
try {
dataReader = new OleDbDataReader(_connection, this, 0, this.commandBehavior);
switch(resultType) {
case ODB.ExecutedIMultipleResults:
dataReader.InitializeIMultipleResults(executeResult);
dataReader.NextResult();
break;
case ODB.ExecutedIRowset:
dataReader.InitializeIRowset(executeResult, ChapterHandle.DB_NULL_HCHAPTER, _recordsAffected);
dataReader.BuildMetaInfo();
dataReader.HasRowsRead();
break;
case ODB.ExecutedIRow:
dataReader.InitializeIRow(executeResult, _recordsAffected);
dataReader.BuildMetaInfo();
break;
case ODB.PrepareICommandText:
if (!_isPrepared) {
PrepareCommandText(2);
}
OleDbDataReader.GenerateSchemaTable(dataReader, _icommandText, behavior);
break;
default:
Debug.Assert(false, "ExecuteReaderInternal: unknown result type");
break;
}
executeResult = null;
_hasDataReader = true;
_connection.AddWeakReference(dataReader, OleDbReferenceCollection.DataReaderTag);
// command stays in the executing state until the connection
// has a datareader to track for it being closed
state = ODB.InternalStateOpen; // MDAC 72655
}
finally {
if (ODB.InternalStateOpen != state) {
this.canceling = true;
if (null != dataReader) {
((IDisposable) dataReader).Dispose();
dataReader = null;
}
}
}
Debug.Assert(null != dataReader, "ExecuteReader should never return a null DataReader");
}
else { // optimized code path for ExecuteNonQuery to not create a OleDbDataReader object
try {
if (ODB.ExecutedIMultipleResults == resultType) {
UnsafeNativeMethods.IMultipleResults multipleResults = (UnsafeNativeMethods.IMultipleResults) executeResult;
// may cause a Connection.ResetState which closes connection
nextResultsFailure = OleDbDataReader.NextResults(multipleResults, _connection, this, out _recordsAffected);
}
}
finally {
try {
if (null != executeResult) {
Marshal.ReleaseComObject(executeResult);
executeResult = null;
}
CloseFromDataReader(ParameterBindings);
}
catch(Exception e) {
//
if (!ADP.IsCatchableExceptionType(e)) {
throw;
}
if (null != nextResultsFailure) {
nextResultsFailure = new OleDbException(nextResultsFailure, e);
}
else {
throw;
}
}
}
}
}
finally { // finally clear executing state
try {
if ((null == dataReader) && (ODB.InternalStateOpen != state)) { // MDAC 67218
ParameterCleanup();
}
}
catch(Exception e) {
//
if (!ADP.IsCatchableExceptionType(e)) {
throw;
}
if (null != nextResultsFailure) {
nextResultsFailure = new OleDbException(nextResultsFailure, e);
}
else {
throw;
}
}
if (null != nextResultsFailure) {
throw nextResultsFailure;
}
}
return dataReader;
}
private int ExecuteCommand(CommandBehavior behavior, out object executeResult) {
if (InitializeCommand(behavior, false)) {
if (0 != (CommandBehavior.SchemaOnly & this.commandBehavior)) {
executeResult = null;
return ODB.PrepareICommandText;
}
return ExecuteCommandText(out executeResult);
}
return ExecuteTableDirect(behavior, out executeResult); // MDAC 57856
}
// dbindings handle can't be freed until the output parameters
// have been filled in which occurs after the last rowset is released
// dbbindings.FreeDataHandle occurs in Cloe
private int ExecuteCommandText(out object executeResult) {
int retcode;
tagDBPARAMS dbParams = null;
RowBinding rowbinding = null;
Bindings bindings = ParameterBindings;
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
if (null != bindings) { // parameters may be suppressed
rowbinding = bindings.RowBinding();
rowbinding.DangerousAddRef(ref mustRelease);
// bindings can't be released until after last rowset is released
// that is when output parameters are populated
// initialize the input parameters to the input databuffer
bindings.ApplyInputParameters();
dbParams = new tagDBPARAMS();
dbParams.pData = rowbinding.DangerousGetDataPtr();
dbParams.cParamSets = 1;
dbParams.hAccessor = rowbinding.DangerousGetAccessorHandle();
}
if ((0 == (CommandBehavior.SingleResult & this.commandBehavior)) && _connection.SupportMultipleResults()) {
retcode = ExecuteCommandTextForMultpleResults(dbParams, out executeResult);
}
else if (0 == (CommandBehavior.SingleRow & this.commandBehavior) || !_executeQuery) {
retcode = ExecuteCommandTextForSingleResult(dbParams, out executeResult);
}
else {
retcode = ExecuteCommandTextForSingleRow(dbParams, out executeResult);
}
}
finally {
if (mustRelease) {
rowbinding.DangerousRelease();
}
}
return retcode;
}
private int ExecuteCommandTextForMultpleResults(tagDBPARAMS dbParams, out object executeResult) {
Debug.Assert(0 == (CommandBehavior.SingleRow & this.commandBehavior), "SingleRow implies SingleResult");
OleDbHResult hr;
Bid.Trace(" %d#, IID_IMultipleResults\n", ObjectID);
hr = _icommandText.Execute(ADP.PtrZero, ref ODB.IID_IMultipleResults, dbParams, out _recordsAffected, out executeResult);
Bid.Trace(" %08X{HRESULT}, RecordsAffected=%Id\n", hr, _recordsAffected);
if (OleDbHResult.E_NOINTERFACE != hr) {
ExecuteCommandTextErrorHandling(hr);
return ODB.ExecutedIMultipleResults;
}
SafeNativeMethods.Wrapper.ClearErrorInfo();
return ExecuteCommandTextForSingleResult(dbParams, out executeResult);
}
private int ExecuteCommandTextForSingleResult(tagDBPARAMS dbParams, out object executeResult) {
OleDbHResult hr;
// MDAC 64465 (Microsoft.Jet.OLEDB.4.0 returns 0 for recordsAffected instead of -1)
if (_executeQuery) {
Bid.Trace(" %d#, IID_IRowset\n", ObjectID);
hr = _icommandText.Execute(ADP.PtrZero, ref ODB.IID_IRowset, dbParams, out _recordsAffected, out executeResult);
Bid.Trace(" %08X{HRESULT}, RecordsAffected=%Id\n", hr, _recordsAffected);
}
else {
Bid.Trace(" %d#, IID_NULL\n", ObjectID);
hr = _icommandText.Execute(ADP.PtrZero, ref ODB.IID_NULL, dbParams, out _recordsAffected, out executeResult);
Bid.Trace(" %08X{HRESULT}, RecordsAffected=%Id\n", hr, _recordsAffected);
}
ExecuteCommandTextErrorHandling(hr);
return ODB.ExecutedIRowset;
}
private int ExecuteCommandTextForSingleRow(tagDBPARAMS dbParams, out object executeResult) {
Debug.Assert(_executeQuery, "ExecuteNonQuery should always use ExecuteCommandTextForSingleResult");
if (_connection.SupportIRow(this)) {
OleDbHResult hr;
Bid.Trace(" %d#, IID_IRow\n", ObjectID);
hr = _icommandText.Execute(ADP.PtrZero, ref ODB.IID_IRow, dbParams, out _recordsAffected, out executeResult);
Bid.Trace(" %08X{HRESULT}, RecordsAffected=%Id\n", hr, _recordsAffected);
if (OleDbHResult.DB_E_NOTFOUND == hr) { // MDAC 76110
SafeNativeMethods.Wrapper.ClearErrorInfo();
return ODB.ExecutedIRow;
}
else if (OleDbHResult.E_NOINTERFACE != hr) {
ExecuteCommandTextErrorHandling(hr);
return ODB.ExecutedIRow;
}
}
SafeNativeMethods.Wrapper.ClearErrorInfo();
return ExecuteCommandTextForSingleResult(dbParams, out executeResult);
}
private void ExecuteCommandTextErrorHandling(OleDbHResult hr) {
Exception e = OleDbConnection.ProcessResults(hr, _connection, this);
if (null != e) {
e = ExecuteCommandTextSpecialErrorHandling(hr, e);
throw e;
}
}
private Exception ExecuteCommandTextSpecialErrorHandling(OleDbHResult hr, Exception e) {
if (((OleDbHResult.DB_E_ERRORSOCCURRED == hr) || (OleDbHResult.DB_E_BADBINDINFO == hr)) && (null != _dbBindings)) { // MDAC 66026, 67039
//
// this code exist to try for a better user error message by post-morten detection
// of invalid parameter types being passed to a provider that doesn't understand
// the user specified parameter OleDbType
Debug.Assert(null != e, "missing inner exception");
StringBuilder builder = new StringBuilder();
ParameterBindings.ParameterStatus(builder);
e = ODB.CommandParameterStatus(builder.ToString(), e);
}
return e;
}
override public int ExecuteNonQuery() {
OleDbConnection.ExecutePermission.Demand();
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#\n", ObjectID);
try {
_executeQuery = false;
ExecuteReaderInternal(CommandBehavior.Default, ADP.ExecuteNonQuery);
return ADP.IntPtrToInt32(_recordsAffected);
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
override public object ExecuteScalar() {
OleDbConnection.ExecutePermission.Demand();
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#\n", ObjectID);
try {
object value = null;
_executeQuery = true;
using(OleDbDataReader reader = ExecuteReaderInternal(CommandBehavior.Default, ADP.ExecuteScalar)) {
if (reader.Read() && (0 < reader.FieldCount)) {
value = reader.GetValue(0);
}
}
return value;
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
private int ExecuteTableDirect(CommandBehavior behavior, out object executeResult) {
this.commandBehavior = behavior;
executeResult = null;
OleDbHResult hr = OleDbHResult.S_OK;
StringMemHandle sptr = null;
bool mustReleaseStringHandle = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
sptr = new StringMemHandle(ExpandCommandText());
sptr.DangerousAddRef(ref mustReleaseStringHandle);
if (mustReleaseStringHandle) {
tagDBID tableID = new tagDBID();
tableID.uGuid = Guid.Empty;
tableID.eKind = ODB.DBKIND_NAME;
tableID.ulPropid = sptr.DangerousGetHandle();
using(IOpenRowsetWrapper iopenRowset = _connection.IOpenRowset()) {
using(DBPropSet propSet = CommandPropertySets()) {
if (null != propSet) {
// MDAC 65279
Bid.Trace(" %d#, IID_IRowset\n", ObjectID);
bool mustRelease = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
propSet.DangerousAddRef(ref mustRelease);
hr = iopenRowset.Value.OpenRowset(ADP.PtrZero, tableID, ADP.PtrZero, ref ODB.IID_IRowset, propSet.PropertySetCount, propSet.DangerousGetHandle(), out executeResult);
}
finally {
if (mustRelease) {
propSet.DangerousRelease();
}
}
Bid.Trace(" %08X{HRESULT}", hr);
if (OleDbHResult.DB_E_ERRORSOCCURRED == hr) {
Bid.Trace(" %d#, IID_IRowset\n", ObjectID);
hr = iopenRowset.Value.OpenRowset(ADP.PtrZero, tableID, ADP.PtrZero, ref ODB.IID_IRowset, 0, IntPtr.Zero, out executeResult);
Bid.Trace(" %08X{HRESULT}", hr);
}
}
else {
Bid.Trace(" %d#, IID_IRowset\n", ObjectID);
hr = iopenRowset.Value.OpenRowset(ADP.PtrZero, tableID, ADP.PtrZero, ref ODB.IID_IRowset, 0, IntPtr.Zero, out executeResult);
Bid.Trace(" %08X{HRESULT}", hr);
}
}
}
}
}
finally {
if (mustReleaseStringHandle) {
sptr.DangerousRelease();
}
}
ProcessResults(hr);
_recordsAffected = ADP.RecordsUnaffected;
return ODB.ExecutedIRowset;
}
private string ExpandCommandText() {
string cmdtxt = CommandText;
if (ADP.IsEmpty(cmdtxt)) {
return ADP.StrEmpty;
}
CommandType cmdtype = CommandType;
switch(cmdtype) {
case System.Data.CommandType.Text:
// do nothing, already expanded by user
return cmdtxt;
case System.Data.CommandType.StoredProcedure:
// { ? = CALL SPROC (? ?) }, { ? = CALL SPROC }, { CALL SPRC (? ?) }, { CALL SPROC }
return ExpandStoredProcedureToText(cmdtxt);
case System.Data.CommandType.TableDirect:
// @devnote: Provider=Jolt4.0 doesn't like quoted table names, SQOLEDB requires them
// Providers should not require table names to be quoted and should guarantee that
// unquoted table names correctly open the specified table, even if the table name
// contains special characters, as long as the table can be unambiguously identified
// without quoting.
return cmdtxt;
default:
throw ADP.InvalidCommandType(cmdtype);
}
}
private string ExpandOdbcMaximumToText(string sproctext, int parameterCount) {
StringBuilder builder = new StringBuilder();
if ((0 < parameterCount) && (ParameterDirection.ReturnValue == Parameters[0].Direction)) {
parameterCount--;
builder.Append("{ ? = CALL ");
}
else {
builder.Append("{ CALL ");
}
builder.Append(sproctext); // WebData 95634
switch(parameterCount) {
case 0:
builder.Append(" }");
break;
case 1:
builder.Append("( ? ) }");
break;
default:
builder.Append("( ?, ?");
for (int i = 2; i < parameterCount; ++i) {
builder.Append(", ?");
}
builder.Append(" ) }");
break;
}
return builder.ToString();
}
private string ExpandOdbcMinimumToText(string sproctext, int parameterCount) {
//if ((0 < parameterCount) && (ParameterDirection.ReturnValue == Parameters[0].Direction)) {
// Debug.Assert("doesn't support ReturnValue parameters");
//}
StringBuilder builder = new StringBuilder();
builder.Append("exec ");
builder.Append(sproctext);
if (0 < parameterCount) {
builder.Append(" ?");
for(int i = 1; i < parameterCount; ++i) {
builder.Append(", ?");
}
}
return builder.ToString();
}
private string ExpandStoredProcedureToText(string sproctext) {
Debug.Assert(null != _connection, "ExpandStoredProcedureToText: null Connection");
int parameterCount = (null != _parameters) ? _parameters.Count : 0;
if (0 == (ODB.DBPROPVAL_SQL_ODBC_MINIMUM & _connection.SqlSupport())) {
return ExpandOdbcMinimumToText(sproctext, parameterCount);
}
return ExpandOdbcMaximumToText(sproctext, parameterCount);
}
private void ParameterCleanup() {
Bindings bindings = ParameterBindings;
if (null != bindings) {
bindings.CleanupBindings();
}
}
private bool InitializeCommand(CommandBehavior behavior, bool throwifnotsupported) {
Debug.Assert(null != _connection, "InitializeCommand: null OleDbConnection");
int changeid = _changeID;
if ((0 != (CommandBehavior.KeyInfo & (this.commandBehavior ^ behavior))) || (_lastChangeID != changeid)) {
CloseInternalParameters(); // could optimize out
CloseInternalCommand();
}
this.commandBehavior = behavior;
changeid = _changeID;
if (!PropertiesOnCommand(false)) {
return false; // MDAC 57856
}
if ((null != _dbBindings) && _dbBindings.AreParameterBindingsInvalid(_parameters)) {
CloseInternalParameters();
}
// if we already having bindings - don't create the accessor
// if _parameters is null - no parameters exist - don't create the collection
// do we actually have parameters since the collection exists
if ((null == _dbBindings) && HasParameters()) {
// if we setup the parameters before setting cmdtxt then named parameters can happen
CreateAccessor();
}
if (_lastChangeID != changeid) {
OleDbHResult hr;
String commandText = ExpandCommandText();
if (Bid.TraceOn) {
Bid.Trace(" %d#, DBGUID_DEFAULT, CommandText='", ObjectID);
Bid.PutStr(commandText); // Use PutStr to write out entire string
Bid.Trace("'\n");
}
hr = _icommandText.SetCommandText(ref ODB.DBGUID_DEFAULT, commandText);
Bid.Trace(" %08X{HRESULT}\n", hr);
if (hr < 0) {
ProcessResults(hr);
}
}
_lastChangeID = changeid;
return true;
}
private void PropertyChanging() {
unchecked { _changeID++; }
}
override public void Prepare() {
OleDbConnection.ExecutePermission.Demand();
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#\n", ObjectID);
try {
if (CommandType.TableDirect != CommandType) { // MDAC 70946, 71194
ValidateConnectionAndTransaction(ADP.Prepare);
_isPrepared = false;
if (CommandType.TableDirect != CommandType) {
InitializeCommand(0, true);
PrepareCommandText(1);
}
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
private void PrepareCommandText(int expectedExecutionCount) {
OleDbParameterCollection parameters = _parameters;
if (null != parameters) {
foreach(OleDbParameter parameter in parameters) {
if (parameter.IsParameterComputed()) {
// @devnote: use IsParameterComputed which is called in the normal case
// only to call Prepare to throw the specialized error message
// reducing the overall number of methods to actually jit
parameter.Prepare(this); // MDAC 70232
}
}
}
UnsafeNativeMethods.ICommandPrepare icommandPrepare = ICommandPrepare();
if (null != icommandPrepare) {
OleDbHResult hr;
Bid.Trace(" %d#, expectedExecutionCount=%d\n", ObjectID, expectedExecutionCount);
hr = icommandPrepare.Prepare(expectedExecutionCount);
Bid.Trace(" %08X{HRESULT}\n", hr);
ProcessResults(hr);
}
// don't recompute bindings on prepared statements
_isPrepared = true;
}
private void ProcessResults(OleDbHResult hr) {
Exception e = OleDbConnection.ProcessResults(hr, _connection, this);
if (null != e) { throw e; }
}
private void ProcessResultsNoReset(OleDbHResult hr) {
Exception e = OleDbConnection.ProcessResults(hr, null, this);
if (null != e) { throw e; }
}
internal object GetPropertyValue(Guid propertySet, int propertyID) {
if (null != _icommandText) {
OleDbHResult hr;
tagDBPROP[] dbprops;
UnsafeNativeMethods.ICommandProperties icommandProperties = ICommandProperties();
using(PropertyIDSet propidset = new PropertyIDSet(propertySet, propertyID)) {
using(DBPropSet propset = new DBPropSet(icommandProperties, propidset, out hr)) {
if (hr < 0) {
SafeNativeMethods.Wrapper.ClearErrorInfo();
}
dbprops = propset.GetPropertySet(0, out propertySet);
}
}
if (OleDbPropertyStatus.Ok == dbprops[0].dwStatus) {
return dbprops[0].vValue;
}
return dbprops[0].dwStatus;
}
return OleDbPropertyStatus.NotSupported;
}
private bool PropertiesOnCommand(bool throwNotSupported) {
if (null != _icommandText) {
return true;
}
Debug.Assert(!_isPrepared, "null command isPrepared");
OleDbConnection connection = _connection;
if (null == connection) {
connection.CheckStateOpen(ODB.Properties);
}
if (!_trackingForClose) {
_trackingForClose = true;
connection.AddWeakReference(this, OleDbReferenceCollection.CommandTag);
}
_icommandText = connection.ICommandText();
if (null == _icommandText) {
if (throwNotSupported || HasParameters()) {
throw ODB.CommandTextNotSupported(connection.Provider, null);
}
return false; // MDAC 57856
}
using(DBPropSet propSet = CommandPropertySets()) {
if (null != propSet) {
UnsafeNativeMethods.ICommandProperties icommandProperties = ICommandProperties();
Bid.Trace(" %d#\n", ObjectID);
OleDbHResult hr = icommandProperties.SetProperties(propSet.PropertySetCount, propSet);
Bid.Trace(" %08X{HRESULT}\n", hr);
if (hr < 0) {
SafeNativeMethods.Wrapper.ClearErrorInfo();
}
}
}
return true;
}
private DBPropSet CommandPropertySets() {
DBPropSet propSet = null;
bool keyInfo = (0 != (CommandBehavior.KeyInfo & this.commandBehavior));
// always set the CommandTimeout value?
int count = (_executeQuery ? (keyInfo ? 4 : 2) : 1);
if (0 < count) {
propSet = new DBPropSet(1);
tagDBPROP[] dbprops = new tagDBPROP[count];
dbprops[0] = new tagDBPROP(ODB.DBPROP_COMMANDTIMEOUT, false, CommandTimeout);
if (_executeQuery) {
// 'Microsoft.Jet.OLEDB.4.0' default is DBPROPVAL_AO_SEQUENTIAL
dbprops[1] = new tagDBPROP(ODB.DBPROP_ACCESSORDER, false, ODB.DBPROPVAL_AO_RANDOM); // MDAC 73030
if (keyInfo) {
// 'Unique Rows' property required for SQLOLEDB to retrieve things like 'BaseTableName'
dbprops[2] = new tagDBPROP(ODB.DBPROP_UNIQUEROWS, false, keyInfo);
// otherwise 'Microsoft.Jet.OLEDB.4.0' doesn't support IColumnsRowset
dbprops[3] = new tagDBPROP(ODB.DBPROP_IColumnsRowset, false, true);
}
}
propSet.SetPropertySet(0, OleDbPropertySetGuid.Rowset, dbprops);
}
return propSet;
}
internal Bindings TakeBindingOwnerShip() {
Bindings bindings = _dbBindings;
_dbBindings = null;
return bindings;
}
private void ValidateConnection(string method) {
if (null == _connection) {
throw ADP.ConnectionRequired(method);
}
_connection.CheckStateOpen(method);
// user attempting to execute the command while the first dataReader hasn't returned
// use the connection reference collection to see if the dataReader referencing this
// command has been garbage collected or not.
if (_hasDataReader) {
if (_connection.HasLiveReader(this)) {
throw ADP.OpenReaderExists();
}
_hasDataReader = false;
}
}
private void ValidateConnectionAndTransaction(string method) {
ValidateConnection(method);
_transaction = _connection.ValidateTransaction(Transaction, method);
this.canceling = false;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ProfileServiceManager.cs
- WizardForm.cs
- ResXResourceSet.cs
- ExceptionUtil.cs
- ToolStripItemEventArgs.cs
- MailAddress.cs
- PingReply.cs
- StateManagedCollection.cs
- StandardTransformFactory.cs
- ExpandedProjectionNode.cs
- EUCJPEncoding.cs
- ValidationService.cs
- FaultContractInfo.cs
- XmlDataImplementation.cs
- Avt.cs
- CoreSwitches.cs
- Site.cs
- AssemblyGen.cs
- PrtCap_Builder.cs
- UdpTransportSettings.cs
- UpdateTracker.cs
- NonParentingControl.cs
- DefaultCommandConverter.cs
- COM2ExtendedUITypeEditor.cs
- NativeMethods.cs
- BatchServiceHost.cs
- SqlDelegatedTransaction.cs
- Variant.cs
- TemplateEditingService.cs
- FloaterParagraph.cs
- DocumentSequenceHighlightLayer.cs
- EntitySetRetriever.cs
- Currency.cs
- RowSpanVector.cs
- OverflowException.cs
- ActivityBindForm.cs
- ColorAnimation.cs
- ExternalFile.cs
- WebPartsPersonalizationAuthorization.cs
- TextTreeUndo.cs
- ArgumentOutOfRangeException.cs
- If.cs
- BindingContext.cs
- XmlCountingReader.cs
- BoolExpression.cs
- IndexingContentUnit.cs
- LocatorPartList.cs
- ScriptBehaviorDescriptor.cs
- XmlHierarchicalDataSourceView.cs
- ParserExtension.cs
- ParseHttpDate.cs
- AssociationEndMember.cs
- GridViewColumn.cs
- ColorContext.cs
- XmlQueryCardinality.cs
- SafeLocalMemHandle.cs
- HttpCookieCollection.cs
- WebPartDeleteVerb.cs
- ActivityCodeDomSerializer.cs
- XmlCollation.cs
- DbConnectionOptions.cs
- BrowserCapabilitiesCodeGenerator.cs
- HttpListenerPrefixCollection.cs
- DataGridRowsPresenter.cs
- HandlerFactoryCache.cs
- KerberosSecurityTokenProvider.cs
- TableColumn.cs
- DecimalAnimationBase.cs
- BlurBitmapEffect.cs
- SpeechAudioFormatInfo.cs
- HttpStreamXmlDictionaryWriter.cs
- TimeZoneNotFoundException.cs
- GetWinFXPath.cs
- PaintValueEventArgs.cs
- ScrollItemPattern.cs
- DynamicResourceExtension.cs
- WSSecurityOneDotOneReceiveSecurityHeader.cs
- GridItemCollection.cs
- Aggregates.cs
- ProjectionNode.cs
- HandlerBase.cs
- ListItemCollection.cs
- ItemList.cs
- xsdvalidator.cs
- Base64Encoding.cs
- IApplicationTrustManager.cs
- cache.cs
- ScrollEventArgs.cs
- SR.cs
- MeshGeometry3D.cs
- BaseDataListPage.cs
- WhereaboutsReader.cs
- CompiledQuery.cs
- RegexCode.cs
- DataGridViewRowErrorTextNeededEventArgs.cs
- SortAction.cs
- ThreadStartException.cs
- SequenceNumber.cs
- PolicyException.cs
- EditorPartChrome.cs