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

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