Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Data / Microsoft / SqlServer / Server / SmiRecordBuffer.cs / 1 / SmiRecordBuffer.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
namespace Microsoft.SqlServer.Server {
using System;
using System.Data;
using System.Data.SqlTypes;
// Class for implementing a record object that could take advantage of the
// environment available to a particular protocol level (such as storing data
// in native structures for in-proc data access). Includes methods to send
// the record to a context pipe (useful for in-proc scenarios).
internal abstract class SmiRecordBuffer : SmiTypedGetterSetter, ITypedGettersV3, ITypedSettersV3, ITypedGetters, ITypedSetters, IDisposable {
#region SMI active methods as of V200
#region control methods
public virtual void Close(
SmiEventSink eventSink
) {
// Adding as of V3
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2- and hasn't implemented V3 yet.
// 2) Server didn't implement V3 on some interface, but negotiated V3+.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
#endregion
#region Supported access method types (Get] vs. Set)
// SmiRecordBuffer defaults both CanGet and CanSet to true to support
// already-shipped SMIV3 record buffer classes. Sub-classes are free to override.
internal override bool CanGet {
get {
return true;
}
}
internal override bool CanSet {
get {
return true;
}
}
#endregion
#region Value getters
// SmiRecordBuffer subclasses that expose CanGet == true must implement all Getters from SmiTypedGetterSetter
// SmiRecordBuffer itself does not need to implement these, since it inherits the default implementation from
// SmiTypedGetterSetter
#endregion
#region Value setters
// SmiRecordBuffer subclasses that expose CanSet == true must implement all Setters from SmiTypedGetterSetter
// SmiRecordBuffer itself does not need to implement these, since it inherits the default implementation from
// SmiTypedGetterSetter
#endregion
#endregion
#region OBSOLETE STUFF than never shipped without obsolete attribute
//
// IDisposable
//
public virtual void Dispose( ) {
// ******** OBSOLETING from SMI -- use Close instead
// Intended to be removed (along with inheriting IDisposable) prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
//
// ITypedGetters methods
//
public virtual bool IsDBNull( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlDbType GetVariantType( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Boolean GetBoolean( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Byte GetByte( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual long GetBytes( int ordinal, long fieldOffset, byte[] buffer, int bufferOffset, int length ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Char GetChar( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual long GetChars( int ordinal, long fieldOffset, char[] buffer, int bufferOffset, int length ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Int16 GetInt16( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Int32 GetInt32( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Int64 GetInt64( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Single GetFloat( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Double GetDouble( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual String GetString( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Decimal GetDecimal( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual DateTime GetDateTime( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Guid GetGuid( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlBoolean GetSqlBoolean( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlByte GetSqlByte( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlInt16 GetSqlInt16( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlInt32 GetSqlInt32( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlInt64 GetSqlInt64( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlSingle GetSqlSingle( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlDouble GetSqlDouble( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlMoney GetSqlMoney( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlDateTime GetSqlDateTime( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlDecimal GetSqlDecimal( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlString GetSqlString( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlBinary GetSqlBinary( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlGuid GetSqlGuid( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlChars GetSqlChars( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlBytes GetSqlBytes( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlXml GetSqlXml( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlXml GetSqlXmlRef( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlBytes GetSqlBytesRef( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlChars GetSqlCharsRef( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
//
// ITypedSetters methods
//
public virtual void SetDBNull( int ordinal ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetBoolean( int ordinal, Boolean value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetByte( int ordinal, Byte value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetBytes( int ordinal, long fieldOffset, byte[] buffer, int bufferOffset, int length ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetChar( int ordinal, char value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetChars( int ordinal, long fieldOffset, char[] buffer, int bufferOffset, int length ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetInt16( int ordinal, Int16 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetInt32( int ordinal, Int32 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetInt64( int ordinal, Int64 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetFloat( int ordinal, Single value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetDouble( int ordinal, Double value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetString( int ordinal, string value )
{
// Implemented as empty virtual method to allow transport to remove it's implementation
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
// 2) Server didn't implement V1 on some interface and negotiated V1.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetString( int ordinal, string value, int offset ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetDecimal( int ordinal, Decimal value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetDateTime( int ordinal, DateTime value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetGuid( int ordinal, Guid value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlBoolean( int ordinal, SqlBoolean value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlByte( int ordinal, SqlByte value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlInt16( int ordinal, SqlInt16 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlInt32( int ordinal, SqlInt32 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlInt64( int ordinal, SqlInt64 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlSingle( int ordinal, SqlSingle value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlDouble( int ordinal, SqlDouble value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlMoney( int ordinal, SqlMoney value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlDateTime( int ordinal, SqlDateTime value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlDecimal( int ordinal, SqlDecimal value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlString( int ordinal, SqlString value )
{
// Implemented as empty virtual method to allow transport to remove it's implementation
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
// 2) Server didn't implement V1 on some interface and negotiated V1.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlString( int ordinal, SqlString value, int offset ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlBinary( int ordinal, SqlBinary value )
{
// Implemented as empty virtual method to allow transport to remove it's implementation
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
// 2) Server didn't implement V1 on some interface and negotiated V1.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlBinary( int ordinal, SqlBinary value, int offset ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlGuid( int ordinal, SqlGuid value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlChars( int ordinal, SqlChars value )
{
// Implemented as empty virtual method to allow transport to remove it's implementation
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
// 2) Server didn't implement V1 on some interface and negotiated V1.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlChars( int ordinal, SqlChars value, int offset ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlBytes( int ordinal, SqlBytes value )
{
// Implemented as empty virtual method to allow transport to remove it's implementation
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
// 2) Server didn't implement V1 on some interface and negotiated V1.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlBytes( int ordinal, SqlBytes value, int offset ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlXml( int ordinal, SqlXml value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
namespace Microsoft.SqlServer.Server {
using System;
using System.Data;
using System.Data.SqlTypes;
// Class for implementing a record object that could take advantage of the
// environment available to a particular protocol level (such as storing data
// in native structures for in-proc data access). Includes methods to send
// the record to a context pipe (useful for in-proc scenarios).
internal abstract class SmiRecordBuffer : SmiTypedGetterSetter, ITypedGettersV3, ITypedSettersV3, ITypedGetters, ITypedSetters, IDisposable {
#region SMI active methods as of V200
#region control methods
public virtual void Close(
SmiEventSink eventSink
) {
// Adding as of V3
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2- and hasn't implemented V3 yet.
// 2) Server didn't implement V3 on some interface, but negotiated V3+.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
#endregion
#region Supported access method types (Get] vs. Set)
// SmiRecordBuffer defaults both CanGet and CanSet to true to support
// already-shipped SMIV3 record buffer classes. Sub-classes are free to override.
internal override bool CanGet {
get {
return true;
}
}
internal override bool CanSet {
get {
return true;
}
}
#endregion
#region Value getters
// SmiRecordBuffer subclasses that expose CanGet == true must implement all Getters from SmiTypedGetterSetter
// SmiRecordBuffer itself does not need to implement these, since it inherits the default implementation from
// SmiTypedGetterSetter
#endregion
#region Value setters
// SmiRecordBuffer subclasses that expose CanSet == true must implement all Setters from SmiTypedGetterSetter
// SmiRecordBuffer itself does not need to implement these, since it inherits the default implementation from
// SmiTypedGetterSetter
#endregion
#endregion
#region OBSOLETE STUFF than never shipped without obsolete attribute
//
// IDisposable
//
public virtual void Dispose( ) {
// ******** OBSOLETING from SMI -- use Close instead
// Intended to be removed (along with inheriting IDisposable) prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
//
// ITypedGetters methods
//
public virtual bool IsDBNull( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlDbType GetVariantType( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Boolean GetBoolean( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Byte GetByte( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual long GetBytes( int ordinal, long fieldOffset, byte[] buffer, int bufferOffset, int length ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Char GetChar( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual long GetChars( int ordinal, long fieldOffset, char[] buffer, int bufferOffset, int length ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Int16 GetInt16( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Int32 GetInt32( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Int64 GetInt64( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Single GetFloat( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Double GetDouble( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual String GetString( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Decimal GetDecimal( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual DateTime GetDateTime( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual Guid GetGuid( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlBoolean GetSqlBoolean( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlByte GetSqlByte( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlInt16 GetSqlInt16( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlInt32 GetSqlInt32( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlInt64 GetSqlInt64( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlSingle GetSqlSingle( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlDouble GetSqlDouble( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlMoney GetSqlMoney( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlDateTime GetSqlDateTime( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlDecimal GetSqlDecimal( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlString GetSqlString( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlBinary GetSqlBinary( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlGuid GetSqlGuid( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlChars GetSqlChars( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlBytes GetSqlBytes( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlXml GetSqlXml( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlXml GetSqlXmlRef( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlBytes GetSqlBytesRef( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual SqlChars GetSqlCharsRef( int ordinal ) {
// ******** OBSOLETING from SMI -- use corresponding ITypedGettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
//
// ITypedSetters methods
//
public virtual void SetDBNull( int ordinal ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetBoolean( int ordinal, Boolean value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetByte( int ordinal, Byte value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetBytes( int ordinal, long fieldOffset, byte[] buffer, int bufferOffset, int length ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetChar( int ordinal, char value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetChars( int ordinal, long fieldOffset, char[] buffer, int bufferOffset, int length ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetInt16( int ordinal, Int16 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetInt32( int ordinal, Int32 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetInt64( int ordinal, Int64 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetFloat( int ordinal, Single value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetDouble( int ordinal, Double value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetString( int ordinal, string value )
{
// Implemented as empty virtual method to allow transport to remove it's implementation
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
// 2) Server didn't implement V1 on some interface and negotiated V1.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetString( int ordinal, string value, int offset ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetDecimal( int ordinal, Decimal value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetDateTime( int ordinal, DateTime value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetGuid( int ordinal, Guid value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlBoolean( int ordinal, SqlBoolean value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlByte( int ordinal, SqlByte value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlInt16( int ordinal, SqlInt16 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlInt32( int ordinal, SqlInt32 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlInt64( int ordinal, SqlInt64 value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlSingle( int ordinal, SqlSingle value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlDouble( int ordinal, SqlDouble value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlMoney( int ordinal, SqlMoney value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlDateTime( int ordinal, SqlDateTime value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlDecimal( int ordinal, SqlDecimal value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlString( int ordinal, SqlString value )
{
// Implemented as empty virtual method to allow transport to remove it's implementation
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
// 2) Server didn't implement V1 on some interface and negotiated V1.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlString( int ordinal, SqlString value, int offset ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlBinary( int ordinal, SqlBinary value )
{
// Implemented as empty virtual method to allow transport to remove it's implementation
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
// 2) Server didn't implement V1 on some interface and negotiated V1.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlBinary( int ordinal, SqlBinary value, int offset ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlGuid( int ordinal, SqlGuid value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlChars( int ordinal, SqlChars value )
{
// Implemented as empty virtual method to allow transport to remove it's implementation
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
// 2) Server didn't implement V1 on some interface and negotiated V1.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlChars( int ordinal, SqlChars value, int offset ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlBytes( int ordinal, SqlBytes value )
{
// Implemented as empty virtual method to allow transport to remove it's implementation
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V2 and dropped support for V1.
// 2) Server didn't implement V1 on some interface and negotiated V1.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlBytes( int ordinal, SqlBytes value, int offset ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
public virtual void SetSqlXml( int ordinal, SqlXml value ) {
// ******** OBSOLETING from SMI -- use ITypedSettersV3 method instead
// Intended to be removed prior to RTM.
// Implement body with throw because there are only a couple of ways to get to this code:
// 1) Client is calling this method even though the server negotiated for V3+ and dropped support for V2-.
// 2) Server didn't implement V2- on some interface and negotiated V2-.
throw System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod );
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- HttpsHostedTransportConfiguration.cs
- XsdValidatingReader.cs
- HotSpot.cs
- FloatUtil.cs
- ProxyGenerator.cs
- Int64.cs
- NavigationWindow.cs
- PluralizationServiceUtil.cs
- WebPartEditVerb.cs
- CacheMode.cs
- OrderingQueryOperator.cs
- MappingSource.cs
- WebRequestModuleElementCollection.cs
- Transform.cs
- XPathNodeInfoAtom.cs
- DataKey.cs
- Trace.cs
- RC2.cs
- odbcmetadatafactory.cs
- ToolConsole.cs
- PageAction.cs
- NetTcpSection.cs
- ObjectResult.cs
- WriteFileContext.cs
- StubHelpers.cs
- RequestDescription.cs
- ThrowOnMultipleAssignment.cs
- DataSourceListEditor.cs
- NetworkAddressChange.cs
- TextDpi.cs
- AsyncCompletedEventArgs.cs
- UnsafeNativeMethods.cs
- ItemsPresenter.cs
- XmlSchemaInferenceException.cs
- CompiledQueryCacheEntry.cs
- DataControlFieldHeaderCell.cs
- FontFamilyIdentifier.cs
- filewebresponse.cs
- userdatakeys.cs
- SamlEvidence.cs
- Regex.cs
- DataBoundControlAdapter.cs
- SqlDataReaderSmi.cs
- MouseBinding.cs
- FormViewModeEventArgs.cs
- TypedColumnHandler.cs
- oledbmetadatacolumnnames.cs
- SafeArrayRankMismatchException.cs
- EdmSchemaAttribute.cs
- SqlConnectionStringBuilder.cs
- NativeMethods.cs
- ExpressionBinding.cs
- ProfileParameter.cs
- BooleanKeyFrameCollection.cs
- Or.cs
- SendDesigner.xaml.cs
- RegexParser.cs
- FileRecordSequenceCompletedAsyncResult.cs
- CacheSection.cs
- XmlArrayItemAttribute.cs
- MarkupWriter.cs
- WebExceptionStatus.cs
- SchemaImporterExtensionElementCollection.cs
- QueryTask.cs
- XmlDataProvider.cs
- storepermission.cs
- Triplet.cs
- XPathDocumentBuilder.cs
- ReflectPropertyDescriptor.cs
- ExceptionHandlersDesigner.cs
- AuthorizationRuleCollection.cs
- TextEndOfParagraph.cs
- PnrpPermission.cs
- PropertySourceInfo.cs
- CheckBox.cs
- MissingFieldException.cs
- DiscoveryReference.cs
- ApplyImportsAction.cs
- SqlUserDefinedAggregateAttribute.cs
- ObjectDataSourceStatusEventArgs.cs
- ParallelRangeManager.cs
- ResourceBinder.cs
- Identity.cs
- GridViewDeleteEventArgs.cs
- BitmapFrameEncode.cs
- TreeNode.cs
- ReaderContextStackData.cs
- ComPlusSynchronizationContext.cs
- ZoomingMessageFilter.cs
- PersianCalendar.cs
- RootBuilder.cs
- DataGridViewEditingControlShowingEventArgs.cs
- HtmlUtf8RawTextWriter.cs
- mactripleDES.cs
- XmlSchemaSimpleTypeUnion.cs
- CheckBoxField.cs
- CheckBoxPopupAdapter.cs
- QueryCacheManager.cs
- SoapReflectionImporter.cs
- WSSecureConversation.cs