mcs/class/referencesource/System.Data/Microsoft/SqlServer/Server/SmiRequestExecutor.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="SmiRequestExecutor.cs" company="Microsoft">
   3 //     Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 // <owner current="true" primary="true">[....]</owner>
   6 // <owner current="true" primary="false">[....]</owner>
   7 //------------------------------------------------------------------------------
   8
   9 namespace Microsoft.SqlServer.Server {
  10
  11     using System;
  12     using System.Data;
  13     using System.Data.SqlTypes;
  14     using System.Transactions;
  15
  16     internal abstract class SmiRequestExecutor : SmiTypedGetterSetter, ITypedSettersV3, ITypedSetters, ITypedGetters, IDisposable {
  17
  18         #region SMI active methods as of V210
  19
  20         #region Overall control methods
  21         public virtual void Close(
  22             SmiEventSink        eventSink
  23         ) {
  24             // Adding as of V3
  25
  26             // Implement body with throw because there are only a couple of ways to get to this code:
  27             //  1) Client is calling this method even though the server negotiated for V2- and hasn't implemented V3 yet.
  28             //  2) Server didn't implement V3 on some interface, but negotiated V3+.
  29             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
  30         }
  31
  32         internal virtual SmiEventStream Execute (
  33             SmiConnection       connection,                     // Assigned connection
  34             long                transactionId,                  // Assigned transaction
  35             Transaction         associatedTransaction,          // SysTx transaction associated with request, if any.
  36             CommandBehavior     behavior,                       // CommandBehavior,
  37             SmiExecuteType      executeType                     // Type of execute called (NonQuery/Pipe/Reader/Row, etc)
  38         )  {
  39             // Adding as of V210
  40
  41             // Implement body with throw because there are only a couple of ways to get to this code:
  42             //  1) Client is calling this method even though the server negotiated for V200- and hasn't implemented V210 yet.
  43             //  2) Server didn't implement V210 on some interface, but negotiated V210+.
  44             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
  45         }
  46
  47         #endregion
  48
  49         #region Supported access method types (Get] vs. Set)
  50
  51         // RequestExecutor only supports setting parameter values, not getting
  52         internal override bool CanGet {
  53             get {
  54                 return false;
  55             }
  56         }
  57
  58         internal override bool CanSet {
  59             get {
  60                 return true;
  61             }
  62         }
  63
  64         #endregion
  65
  66         // SmiRequestExecutor and it's subclasses should NOT override Getters from SmiTypedGetterSetter
  67         //  Calls against those methods on a Request Executor are not allowed.
  68
  69         #region Value setters
  70
  71         // Set DEFAULT bit for parameter
  72         internal abstract void SetDefault( int ordinal );
  73
  74         // SmiRequestExecutor subclasses must implement all Setters from SmiTypedGetterSetter
  75         //  SmiRequestExecutor itself does not need to implement these, since it inherits the default implementation from
  76         //      SmiTypedGetterSetter
  77
  78         #endregion
  79         #endregion
  80
  81         #region Obsolete as of V210
  82         internal virtual SmiEventStream Execute (
  83             SmiConnection       connection,                     // Assigned connection
  84             long                transactionId,                  // Assigned transaction
  85             CommandBehavior     behavior,                       // CommandBehavior,
  86             SmiExecuteType      executeType                     // Type of execute called (NonQuery/Pipe/Reader/Row, etc)
  87         )  {
  88             // Obsoleting as of V210
  89
  90             // Implement body with throw because there are only a couple of ways to get to this code:
  91             //  1) Client is calling this method even though the server negotiated for V210+ (and doesn't implement it).
  92             //  2) Server doesn't implement this method, but negotiated V200-.
  93             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
  94         }
  95         #endregion
  96
  97         #region OBSOLETE STUFF that never shipped without obsolete attribute
  98
  99         //
 100         //  IDisposable
 101         //
 102         public virtual void Dispose( ) {
 103             // ******** OBSOLETING from SMI -- use close instead.
 104             //  Intended to be removed (along with removing inheriting IDisposable) prior to RTM.
 105
 106             // Implement body with throw because there are only a couple of ways to get to this code:
 107             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 108             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 109             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 110         }
 111
 112         // Check to see if parameter's DEFAULT bit is set
 113         internal virtual bool IsSetAsDefault( int ordinal ) {
 114             // ******** OBSOLETING from SMI -- Not needed.
 115             //  Intended to be removed prior to RTM.
 116
 117             // Implement body with throw because there are only a couple of ways to get to this code:
 118             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 119             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 120             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 121         }
 122
 123         // Get the count of parameters
 124         public virtual int Count {
 125             get {
 126                 // ******** OBSOLETING from SMI -- front end needs to keep track of input param metadata itself.  Outparam metadata comes with ParametersAvailable event.
 127                 //  Intended to be removed prior to RTM.
 128
 129                 // Implement body with throw because there are only a couple of ways to get to this code:
 130                 //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 131                 //  2) Server didn't implement V2- on some interface and negotiated V2-.
 132                 throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 133             }
 134         }
 135
 136         // Get the meta data associated with the parameter.
 137         public virtual SmiParameterMetaData GetMetaData( int ordinal ) {
 138             // ******** OBSOLETING from SMI -- front end needs to keep track of input param metadata itself.  Outparam metadata comes with ParametersAvailable event.
 139             //  Intended to be removed prior to RTM.
 140
 141             // Implement body with throw because there are only a couple of ways to get to this code:
 142             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 143             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 144             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 145         }
 146
 147         //
 148         //  ITypedGetters methods (for output parameters)  (OBSOLETE)
 149         //
 150         public virtual bool IsDBNull( int ordinal ) {
 151             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 152             //  Intended to be removed prior to RTM.
 153
 154             // Implement body with throw because there are only a couple of ways to get to this code:
 155             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 156             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 157             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 158         }
 159
 160         public virtual SqlDbType GetVariantType( int ordinal ) {
 161             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 162             //  Intended to be removed prior to RTM.
 163
 164             // Implement body with throw because there are only a couple of ways to get to this code:
 165             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 166             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 167             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 168         }
 169
 170         public virtual Boolean GetBoolean( int ordinal ) {
 171             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 172             //  Intended to be removed prior to RTM.
 173
 174             // Implement body with throw because there are only a couple of ways to get to this code:
 175             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 176             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 177             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 178         }
 179
 180         public virtual Byte GetByte( int ordinal ) {
 181             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 182             //  Intended to be removed prior to RTM.
 183
 184             // Implement body with throw because there are only a couple of ways to get to this code:
 185             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 186             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 187             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 188         }
 189
 190         public virtual long GetBytes( int ordinal, long fieldOffset, byte[] buffer, int bufferOffset, int length ) {
 191             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 192             //  Intended to be removed prior to RTM.
 193
 194             // Implement body with throw because there are only a couple of ways to get to this code:
 195             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 196             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 197             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 198         }
 199
 200         public virtual Char GetChar( int ordinal ) {
 201             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 202             //  Intended to be removed prior to RTM.
 203
 204             // Implement body with throw because there are only a couple of ways to get to this code:
 205             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 206             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 207             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 208         }
 209
 210         public virtual long GetChars( int ordinal, long fieldOffset, char[] buffer, int bufferOffset, int length ) {
 211             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 212             //  Intended to be removed prior to RTM.
 213
 214             // Implement body with throw because there are only a couple of ways to get to this code:
 215             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 216             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 217             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 218         }
 219
 220         public virtual Int16 GetInt16( int ordinal ) {
 221             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 222             //  Intended to be removed prior to RTM.
 223
 224             // Implement body with throw because there are only a couple of ways to get to this code:
 225             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 226             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 227             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 228         }
 229
 230         public virtual Int32 GetInt32( int ordinal ) {
 231             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 232             //  Intended to be removed prior to RTM.
 233
 234             // Implement body with throw because there are only a couple of ways to get to this code:
 235             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 236             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 237             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 238         }
 239
 240         public virtual Int64 GetInt64( int ordinal ) {
 241             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 242             //  Intended to be removed prior to RTM.
 243
 244             // Implement body with throw because there are only a couple of ways to get to this code:
 245             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 246             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 247             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 248         }
 249
 250         public virtual Single GetFloat( int ordinal ) {
 251             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 252             //  Intended to be removed prior to RTM.
 253
 254             // Implement body with throw because there are only a couple of ways to get to this code:
 255             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 256             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 257             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 258         }
 259
 260         public virtual Double GetDouble( int ordinal ) {
 261             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 262             //  Intended to be removed prior to RTM.
 263
 264             // Implement body with throw because there are only a couple of ways to get to this code:
 265             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 266             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 267             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 268         }
 269
 270         public virtual String GetString( int ordinal ) {
 271             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 272             //  Intended to be removed prior to RTM.
 273
 274             // Implement body with throw because there are only a couple of ways to get to this code:
 275             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 276             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 277             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 278         }
 279
 280         public virtual Decimal GetDecimal( int ordinal ) {
 281             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 282             //  Intended to be removed prior to RTM.
 283
 284             // Implement body with throw because there are only a couple of ways to get to this code:
 285             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 286             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 287             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 288         }
 289
 290         public virtual DateTime GetDateTime( int ordinal ) {
 291             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 292             //  Intended to be removed prior to RTM.
 293
 294             // Implement body with throw because there are only a couple of ways to get to this code:
 295             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 296             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 297             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 298         }
 299
 300         public virtual Guid GetGuid( int ordinal ) {
 301             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 302             //  Intended to be removed prior to RTM.
 303
 304             // Implement body with throw because there are only a couple of ways to get to this code:
 305             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 306             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 307             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 308         }
 309
 310         public virtual SqlBoolean GetSqlBoolean( int ordinal ) {
 311             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 312             //  Intended to be removed prior to RTM.
 313
 314             // Implement body with throw because there are only a couple of ways to get to this code:
 315             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 316             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 317             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 318         }
 319
 320         public virtual SqlByte GetSqlByte( int ordinal ) {
 321             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 322             //  Intended to be removed prior to RTM.
 323
 324             // Implement body with throw because there are only a couple of ways to get to this code:
 325             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 326             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 327             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 328         }
 329
 330         public virtual SqlInt16 GetSqlInt16( int ordinal ) {
 331             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 332             //  Intended to be removed prior to RTM.
 333
 334             // Implement body with throw because there are only a couple of ways to get to this code:
 335             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 336             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 337             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 338         }
 339
 340         public virtual SqlInt32 GetSqlInt32( int ordinal ) {
 341             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 342             //  Intended to be removed prior to RTM.
 343
 344             // Implement body with throw because there are only a couple of ways to get to this code:
 345             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 346             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 347             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 348         }
 349
 350         public virtual SqlInt64 GetSqlInt64( int ordinal ) {
 351             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 352             //  Intended to be removed prior to RTM.
 353
 354             // Implement body with throw because there are only a couple of ways to get to this code:
 355             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 356             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 357             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 358         }
 359
 360         public virtual SqlSingle GetSqlSingle( int ordinal ) {
 361             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 362             //  Intended to be removed prior to RTM.
 363
 364             // Implement body with throw because there are only a couple of ways to get to this code:
 365             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 366             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 367             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 368         }
 369
 370         public virtual SqlDouble GetSqlDouble( int ordinal ) {
 371             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 372             //  Intended to be removed prior to RTM.
 373
 374             // Implement body with throw because there are only a couple of ways to get to this code:
 375             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 376             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 377             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 378         }
 379
 380         public virtual SqlMoney GetSqlMoney( int ordinal ) {
 381             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 382             //  Intended to be removed prior to RTM.
 383
 384             // Implement body with throw because there are only a couple of ways to get to this code:
 385             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 386             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 387             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 388         }
 389
 390         public virtual SqlDateTime GetSqlDateTime( int ordinal ) {
 391             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 392             //  Intended to be removed prior to RTM.
 393
 394             // Implement body with throw because there are only a couple of ways to get to this code:
 395             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 396             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 397             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 398         }
 399
 400         public virtual SqlDecimal GetSqlDecimal( int ordinal ) {
 401             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 402             //  Intended to be removed prior to RTM.
 403
 404             // Implement body with throw because there are only a couple of ways to get to this code:
 405             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 406             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 407             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 408         }
 409
 410         public virtual SqlString GetSqlString( int ordinal ) {
 411             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 412             //  Intended to be removed prior to RTM.
 413
 414             // Implement body with throw because there are only a couple of ways to get to this code:
 415             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 416             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 417             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 418         }
 419
 420         public virtual SqlBinary GetSqlBinary( int ordinal ) {
 421             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 422             //  Intended to be removed prior to RTM.
 423
 424             // Implement body with throw because there are only a couple of ways to get to this code:
 425             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 426             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 427             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 428         }
 429
 430         public virtual SqlGuid GetSqlGuid( int ordinal ) {
 431             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 432             //  Intended to be removed prior to RTM.
 433
 434             // Implement body with throw because there are only a couple of ways to get to this code:
 435             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 436             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 437             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 438         }
 439
 440         public virtual SqlChars GetSqlChars( int ordinal ) {
 441             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 442             //  Intended to be removed prior to RTM.
 443
 444             // Implement body with throw because there are only a couple of ways to get to this code:
 445             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 446             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 447             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 448         }
 449
 450         public virtual SqlBytes GetSqlBytes( int ordinal ) {
 451             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 452             //  Intended to be removed prior to RTM.
 453
 454             // Implement body with throw because there are only a couple of ways to get to this code:
 455             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 456             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 457             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 458         }
 459
 460         public virtual SqlXml GetSqlXml( int ordinal ) {
 461             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 462             //  Intended to be removed prior to RTM.
 463
 464             // Implement body with throw because there are only a couple of ways to get to this code:
 465             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 466             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 467             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 468         }
 469
 470         public virtual SqlXml GetSqlXmlRef( int ordinal ) {
 471             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 472             //  Intended to be removed prior to RTM.
 473
 474             // Implement body with throw because there are only a couple of ways to get to this code:
 475             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 476             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 477             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 478         }
 479
 480         public virtual SqlBytes GetSqlBytesRef( int ordinal ) {
 481             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 482             //  Intended to be removed prior to RTM.
 483
 484             // Implement body with throw because there are only a couple of ways to get to this code:
 485             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 486             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 487             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 488         }
 489
 490         public virtual SqlChars GetSqlCharsRef( int ordinal ) {
 491             // ******** OBSOLETING from SMI -- use ITypedGettersV3 in ParametersAvailable event instead
 492             //  Intended to be removed prior to RTM.
 493
 494             // Implement body with throw because there are only a couple of ways to get to this code:
 495             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 496             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 497             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 498         }
 499
 500         //
 501         //  ITypedSetters methods
 502         //
 503         public virtual void SetDBNull( int ordinal ) {
 504             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 505             //  Intended to be removed prior to RTM.
 506
 507             // Implement body with throw because there are only a couple of ways to get to this code:
 508             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 509             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 510             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 511         }
 512
 513         public virtual void SetBoolean( int ordinal, Boolean value ) {
 514             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 515             //  Intended to be removed prior to RTM.
 516
 517             // Implement body with throw because there are only a couple of ways to get to this code:
 518             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 519             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 520             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 521         }
 522
 523         public virtual void SetByte( int ordinal, Byte value ) {
 524             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 525             //  Intended to be removed prior to RTM.
 526
 527             // Implement body with throw because there are only a couple of ways to get to this code:
 528             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 529             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 530             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 531         }
 532
 533         public virtual void SetBytes( int ordinal, long fieldOffset, byte[] buffer, int bufferOffset, int length ) {
 534             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 535             //  Intended to be removed prior to RTM.
 536
 537             // Implement body with throw because there are only a couple of ways to get to this code:
 538             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 539             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 540             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 541         }
 542
 543         public virtual void SetChar( int ordinal, char value ) {
 544             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 545             //  Intended to be removed prior to RTM.
 546
 547             // Implement body with throw because there are only a couple of ways to get to this code:
 548             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 549             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 550             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 551         }
 552
 553         public virtual void SetChars( int ordinal, long fieldOffset, char[] buffer, int bufferOffset, int length ) {
 554             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 555             //  Intended to be removed prior to RTM.
 556
 557             // Implement body with throw because there are only a couple of ways to get to this code:
 558             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 559             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 560             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 561         }
 562
 563         public virtual void SetInt16( int ordinal, Int16 value ) {
 564             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 565             //  Intended to be removed prior to RTM.
 566
 567             // Implement body with throw because there are only a couple of ways to get to this code:
 568             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 569             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 570             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 571         }
 572
 573         public virtual void SetInt32( int ordinal, Int32 value ) {
 574             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 575             //  Intended to be removed prior to RTM.
 576
 577             // Implement body with throw because there are only a couple of ways to get to this code:
 578             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 579             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 580             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 581         }
 582
 583         public virtual void SetInt64( int ordinal, Int64 value ) {
 584             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 585             //  Intended to be removed prior to RTM.
 586
 587             // Implement body with throw because there are only a couple of ways to get to this code:
 588             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 589             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 590             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 591         }
 592
 593         public virtual void SetFloat( int ordinal, Single value ) {
 594             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 595             //  Intended to be removed prior to RTM.
 596
 597             // Implement body with throw because there are only a couple of ways to get to this code:
 598             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 599             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 600             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 601         }
 602
 603         public virtual void SetDouble( int ordinal,  Double value ) {
 604             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 605             //  Intended to be removed prior to RTM.
 606
 607             // Implement body with throw because there are only a couple of ways to get to this code:
 608             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 609             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 610             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 611         }
 612
 613         public virtual void SetString( int ordinal, string value )
 614             {
 615             // Implemented as virtual method to allow transport to remove it's implementation
 616
 617             // Implement body with throw because there are only a couple of ways to get to this code:
 618             //  1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
 619             //  2) Server didn't implement V1 on some interface and negotiated V1.
 620             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 621             }
 622
 623         public virtual void SetString( int ordinal, string value, int offset ) {
 624             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 625             //  Intended to be removed prior to RTM.
 626
 627             // Implement body with throw because there are only a couple of ways to get to this code:
 628             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 629             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 630             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 631         }
 632
 633         public virtual void SetDecimal( int ordinal, Decimal value ) {
 634             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 635             //  Intended to be removed prior to RTM.
 636
 637             // Implement body with throw because there are only a couple of ways to get to this code:
 638             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 639             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 640             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 641         }
 642
 643         public virtual void SetDateTime( int ordinal, DateTime value ) {
 644             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 645             //  Intended to be removed prior to RTM.
 646
 647             // Implement body with throw because there are only a couple of ways to get to this code:
 648             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 649             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 650             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 651         }
 652
 653         public virtual void SetGuid( int ordinal, Guid value ) {
 654             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 655             //  Intended to be removed prior to RTM.
 656
 657             // Implement body with throw because there are only a couple of ways to get to this code:
 658             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 659             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 660             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 661         }
 662
 663         public virtual void SetSqlBoolean( int ordinal, SqlBoolean value ) {
 664             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 665             //  Intended to be removed prior to RTM.
 666
 667             // Implement body with throw because there are only a couple of ways to get to this code:
 668             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 669             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 670             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 671         }
 672
 673         public virtual void SetSqlByte( int ordinal, SqlByte value ) {
 674             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 675             //  Intended to be removed prior to RTM.
 676
 677             // Implement body with throw because there are only a couple of ways to get to this code:
 678             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 679             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 680             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 681         }
 682
 683         public virtual void SetSqlInt16( int ordinal, SqlInt16 value ) {
 684             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 685             //  Intended to be removed prior to RTM.
 686
 687             // Implement body with throw because there are only a couple of ways to get to this code:
 688             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 689             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 690             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 691         }
 692
 693         public virtual void SetSqlInt32( int ordinal, SqlInt32 value ) {
 694             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 695             //  Intended to be removed prior to RTM.
 696
 697             // Implement body with throw because there are only a couple of ways to get to this code:
 698             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 699             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 700             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 701         }
 702
 703         public virtual void SetSqlInt64( int ordinal, SqlInt64 value ) {
 704             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 705             //  Intended to be removed prior to RTM.
 706
 707             // Implement body with throw because there are only a couple of ways to get to this code:
 708             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 709             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 710             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 711         }
 712
 713         public virtual void SetSqlSingle( int ordinal, SqlSingle value ) {
 714             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 715             //  Intended to be removed prior to RTM.
 716
 717             // Implement body with throw because there are only a couple of ways to get to this code:
 718             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 719             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 720             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 721         }
 722
 723         public virtual void SetSqlDouble( int ordinal, SqlDouble value ) {
 724             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 725             //  Intended to be removed prior to RTM.
 726
 727             // Implement body with throw because there are only a couple of ways to get to this code:
 728             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 729             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 730             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 731         }
 732
 733         public virtual void SetSqlMoney( int ordinal, SqlMoney value ) {
 734             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 735             //  Intended to be removed prior to RTM.
 736
 737             // Implement body with throw because there are only a couple of ways to get to this code:
 738             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 739             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 740             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 741         }
 742
 743         public virtual void SetSqlDateTime( int ordinal, SqlDateTime value ) {
 744             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 745             //  Intended to be removed prior to RTM.
 746
 747             // Implement body with throw because there are only a couple of ways to get to this code:
 748             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 749             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 750             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 751         }
 752
 753         public virtual void SetSqlDecimal( int ordinal, SqlDecimal value ) {
 754             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 755             //  Intended to be removed prior to RTM.
 756
 757             // Implement body with throw because there are only a couple of ways to get to this code:
 758             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 759             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 760             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 761         }
 762
 763         public virtual void SetSqlString( int ordinal, SqlString value )
 764             {
 765             // Implemented as empty virtual method to allow transport to remove it's implementation
 766
 767             // Implement body with throw because there are only a couple of ways to get to this code:
 768             //  1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
 769             //  2) Server didn't implement V1 on some interface and negotiated V1.
 770             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 771             }
 772
 773         public virtual void SetSqlString( int ordinal, SqlString value, int offset ) {
 774             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 775             //  Intended to be removed prior to RTM.
 776
 777             // Implement body with throw because there are only a couple of ways to get to this code:
 778             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 779             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 780             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 781         }
 782
 783         public virtual void SetSqlBinary( int ordinal, SqlBinary value )
 784             {
 785             // Implemented as empty virtual method to allow transport to remove it's implementation
 786
 787             // Implement body with throw because there are only a couple of ways to get to this code:
 788             //  1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
 789             //  2) Server didn't implement V1 on some interface and negotiated V1.
 790             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 791             }
 792
 793         public virtual void SetSqlBinary( int ordinal, SqlBinary value, int offset ) {
 794             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 795             //  Intended to be removed prior to RTM.
 796
 797             // Implement body with throw because there are only a couple of ways to get to this code:
 798             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 799             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 800             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 801         }
 802
 803         public virtual void SetSqlGuid( int ordinal, SqlGuid value ) {
 804             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 805             //  Intended to be removed prior to RTM.
 806
 807             // Implement body with throw because there are only a couple of ways to get to this code:
 808             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 809             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 810             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 811         }
 812
 813         public virtual void SetSqlChars( int ordinal, SqlChars value )
 814             {
 815             // Implemented as empty virtual method to allow transport to remove it's implementation
 816
 817             // Implement body with throw because there are only a couple of ways to get to this code:
 818             //  1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
 819             //  2) Server didn't implement V1 on some interface and negotiated V1.
 820             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 821             }
 822
 823         public virtual void SetSqlChars( int ordinal, SqlChars value, int offset ) {
 824             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 825             //  Intended to be removed prior to RTM.
 826
 827             // Implement body with throw because there are only a couple of ways to get to this code:
 828             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 829             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 830             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 831         }
 832
 833         public virtual void SetSqlBytes( int ordinal, SqlBytes value )
 834             {
 835             // Implemented as empty virtual method to allow transport to remove it's implementation
 836
 837             // Implement body with throw because there are only a couple of ways to get to this code:
 838             //  1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
 839             //  2) Server didn't implement V1 on some interface and negotiated V1.
 840             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 841             }
 842
 843         public virtual void SetSqlBytes( int ordinal, SqlBytes value, int offset ) {
 844             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 845             //  Intended to be removed prior to RTM.
 846
 847             // Implement body with throw because there are only a couple of ways to get to this code:
 848             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 849             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 850             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 851         }
 852
 853         public virtual void SetSqlXml( int ordinal, SqlXml value ) {
 854             // ******** OBSOLETING from SMI -- use related ITypedSettersV3 method instead
 855             //  Intended to be removed prior to RTM.
 856
 857             // Implement body with throw because there are only a couple of ways to get to this code:
 858             //  1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
 859             //  2) Server didn't implement V2- on some interface and negotiated V2-.
 860             throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
 861         }
 862         #endregion
 863     }
 864 }