internal static bool IsGetterAccessValid(SmiMetaData metaData, SmiXetterTypeCode xetterType)
{
// Make sure no-one adds a new xetter type without updating this file!
Debug.Assert(SmiXetterTypeCode.XetBoolean <= xetterType && SmiXetterTypeCode.XetDateTimeOffset >= xetterType);
return(__isGetterAccessValid[(int)metaData.SqlDbType, (int)xetterType]);
}
// valid for DateTimeOffset
internal void SetDateTimeOffset(DateTimeOffset value)
{
Debug.Assert(
SmiXetterAccessMap.IsSetterAccessValid(_metaData, SmiXetterTypeCode.XetDateTimeOffset));
byte scale;
byte length;
if (SqlDbType.Variant == _metaData.SqlDbType)
{
// VSTFDevDiv #885208 - DateTimeOffset throws ArgumentException for when passing DateTimeOffset value to a sql_variant TVP
// using a SqlDataRecord or SqlDataReader
MSS.SmiMetaData dateTimeOffsetMetaData = MSS.SmiMetaData.DefaultDateTimeOffset;
scale = MetaType.MetaDateTimeOffset.Scale;
length = (byte)dateTimeOffsetMetaData.MaxLength;
_stateObj.Parser.WriteSqlVariantHeader(13, TdsEnums.SQLDATETIMEOFFSET, 1, _stateObj);
_stateObj.WriteByte(scale); //propbytes: scale
}
else
{
scale = _metaData.Scale;
length = (byte)_metaData.MaxLength;
_stateObj.WriteByte(length);
}
DateTime utcDateTime = value.UtcDateTime;
long time = utcDateTime.TimeOfDay.Ticks / TdsEnums.TICKS_FROM_SCALE[scale];
int days = utcDateTime.Subtract(DateTime.MinValue).Days;
short offset = (short)value.Offset.TotalMinutes;
_stateObj.WriteByteArray(BitConverter.GetBytes(time), length - 5, 0); // time
_stateObj.WriteByteArray(BitConverter.GetBytes(days), 3, 0); // date
_stateObj.WriteByte((byte)(offset & 0xff)); // offset byte 1
_stateObj.WriteByte((byte)((offset >> 8) & 0xff)); // offset byte 2
}
public virtual object GetSqlValue(int ordinal)
{
EnsureSubclassOverride();
SmiMetaData metaData = GetSmiMetaData(ordinal);
return(ValueUtilsSmi.GetSqlValue200(_eventSink, _recordBuffer, ordinal, metaData));
}
public virtual Object GetValue(int ordinal)
{
EnsureSubclassOverride();
SmiMetaData metaData = GetSmiMetaData(ordinal);
if (SmiVersion >= SmiContextFactory.KatmaiVersion)
{
return(ValueUtilsSmi.GetValue200(
_eventSink,
_recordBuffer,
ordinal,
metaData,
_recordContext
));
}
else
{
return(ValueUtilsSmi.GetValue(
_eventSink,
(ITypedGettersV3)_recordBuffer,
ordinal,
metaData,
_recordContext
));
}
}
private static long GetBytesConversion(SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData, long fieldOffset, byte[] buffer, int bufferOffset, int length, bool throwOnNull) {
object obj = GetSqlValue( sink, getters, ordinal, metaData, null );
if (null == obj) {
throw ADP.InvalidCast();
}
SqlBinary value = (SqlBinary) obj;
if (value.IsNull) {
if (throwOnNull) {
throw SQL.SqlNullValue();
}
else {
// return zero length in any case
return 0;
}
}
if ( null == buffer ) {
return value.Length;
}
length = CheckXetParameters( metaData.SqlDbType, metaData.MaxLength * sizeof(char), value.Length,
fieldOffset, buffer.Length, bufferOffset, length );
Array.Copy( value.Value, checked((int)fieldOffset), buffer, bufferOffset, length );
return length;
}
internal SmiSettersStream(SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData)
{
this._sink = sink;
this._setters = setters;
this._ordinal = ordinal;
this._lengthWritten = 0L;
this._metaData = metaData;
}
internal SmiGettersStream(SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData)
{
this._sink = sink;
this._getters = getters;
this._ordinal = ordinal;
this._readPosition = 0L;
this._metaData = metaData;
}
internal TdsValueSetter(TdsParserStateObject stateObj, SmiMetaData md)
{
this._stateObj = stateObj;
this._metaData = md;
this._isPlp = MetaDataUtilsSmi.IsPlpFormat(md);
this._plpUnknownSent = false;
this._encoder = null;
}
// Does this type use PLP format values?
internal static bool IsPlpFormat(SmiMetaData metaData)
{
return(metaData.MaxLength == SmiMetaData.UnlimitedMaxLengthIndicator ||
metaData.SqlDbType == SqlDbType.Image ||
metaData.SqlDbType == SqlDbType.NText ||
metaData.SqlDbType == SqlDbType.Text ||
metaData.SqlDbType == SqlDbType.Udt);
}
internal static bool IsPlpFormat(SmiMetaData metaData)
{
if (((metaData.MaxLength != -1L) && (metaData.SqlDbType != SqlDbType.Image)) && ((metaData.SqlDbType != SqlDbType.NText) && (metaData.SqlDbType != SqlDbType.Text)))
{
return(metaData.SqlDbType == SqlDbType.Udt);
}
return(true);
}
internal SmiSettersStream(SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData)
{
this._sink = sink;
this._setters = setters;
this._ordinal = ordinal;
this._lengthWritten = 0L;
this._metaData = metaData;
}
internal SmiGettersStream(SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData)
{
this._sink = sink;
this._getters = getters;
this._ordinal = ordinal;
this._readPosition = 0L;
this._metaData = metaData;
}
internal MemoryRecordBuffer(SmiMetaData[] metaData) {
Debug.Assert(null != metaData, "invalid attempt to instantiate MemoryRecordBuffer with null SmiMetaData[]");
_buffer = new SqlRecordBuffer[metaData.Length];
for (int i = 0; i < _buffer.Length; ++i) {
_buffer[i] = new SqlRecordBuffer(metaData[i]);
}
}
internal TdsRecordBufferSetter(TdsParserStateObject stateObj, SmiMetaData md)
{
this._fieldSetters = new TdsValueSetter[md.FieldMetaData.Count];
for (int i = 0; i < md.FieldMetaData.Count; i++)
{
this._fieldSetters[i] = new TdsValueSetter(stateObj, md.FieldMetaData[i]);
}
this._stateObj = stateObj;
this._metaData = md;
}
public virtual void SetVariantMetaData(SmiEventSink sink, int ordinal, SmiMetaData metaData)
{
// ******** OBSOLETING from SMI -- this should have been removed from ITypedSettersV3
// Intended to be removed prior to RTM. Sub-classes need not implement
// 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);
}
private int _currentOffset; // for chunking, verify that caller is using correct offsets
#endif
#endregion
#region Exposed Construct/factory methods
internal TdsValueSetter(TdsParserStateObject stateObj, SmiMetaData md) {
_stateObj = stateObj;
_metaData = md;
_isPlp = MetaDataUtilsSmi.IsPlpFormat(md);
_plpUnknownSent = false;
_encoder = null;
#if DEBUG
_currentOffset = 0;
#endif
}
// compare SmiMetaData to SqlMetaData and determine if they are compatible.
internal static bool IsCompatible(SmiMetaData firstMd, SqlMetaData secondMd)
{
return(firstMd.SqlDbType == secondMd.SqlDbType &&
firstMd.MaxLength == secondMd.MaxLength &&
firstMd.Precision == secondMd.Precision &&
firstMd.Scale == secondMd.Scale &&
firstMd.CompareOptions == secondMd.CompareOptions &&
firstMd.LocaleId == secondMd.LocaleId &&
firstMd.SqlDbType != SqlDbType.Structured && // SqlMetaData doesn't support Structured types
!firstMd.IsMultiValued); // SqlMetaData doesn't have a "multivalued" option
}
internal static byte GetByte( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData ) {
ThrowIfITypedGettersIsNull( sink, getters, ordinal );
if ( CanAccessGetterDirectly( metaData, ExtendedClrTypeCode.Byte ) ) {
return GetByte_Unchecked( sink, getters, ordinal );
}
object result = GetValue( sink, getters, ordinal, metaData, null );
if (null == result) {
throw ADP.InvalidCast();
}
return (Byte)result;
}
public virtual string GetString(int ordinal)
{
this.EnsureSubclassOverride();
SmiMetaData smiMetaData = this.GetSmiMetaData(ordinal);
if (this._usesStringStorageForXml && (SqlDbType.Xml == smiMetaData.SqlDbType))
{
return(ValueUtilsSmi.GetString(this._eventSink, this._recordBuffer, ordinal, __maxNVarCharForXml));
}
return(ValueUtilsSmi.GetString(this._eventSink, this._recordBuffer, ordinal, this.GetSmiMetaData(ordinal)));
}
public virtual object GetValue(int ordinal)
{
this.EnsureSubclassOverride();
SmiMetaData smiMetaData = this.GetSmiMetaData(ordinal);
if (this.SmiVersion >= 210L)
{
return(ValueUtilsSmi.GetValue200(this._eventSink, this._recordBuffer, ordinal, smiMetaData, this._recordContext));
}
return(ValueUtilsSmi.GetValue(this._eventSink, this._recordBuffer, ordinal, smiMetaData, this._recordContext));
}
private int _currentField; // validate that caller sets columns in correct order.
#endif
#endregion
#region Exposed Construct and control methods/properties
internal TdsRecordBufferSetter(TdsParserStateObject stateObj, SmiMetaData md) {
Debug.Assert(SqlDbType.Structured == md.SqlDbType, "Unsupported SqlDbType: " + md.SqlDbType);
_fieldSetters = new TdsValueSetter[md.FieldMetaData.Count];
for(int i=0; i<md.FieldMetaData.Count; i++) {
_fieldSetters[i] = new TdsValueSetter(stateObj, md.FieldMetaData[i]);
}
_stateObj = stateObj;
_metaData = md;
#if DEBUG
_currentField = ReadyForToken;
#endif
}
internal SmiGettersStream( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData ) {
Debug.Assert( null != sink );
Debug.Assert( null != getters );
Debug.Assert( 0 <= ordinal );
Debug.Assert( null != metaData );
_sink = sink;
_getters = getters;
_ordinal = ordinal;
_readPosition = 0;
_metaData = metaData;
}
internal SmiSettersStream( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData ) {
Debug.Assert( null != sink );
Debug.Assert( null != setters );
Debug.Assert( 0 <= ordinal );
Debug.Assert( null != metaData );
_sink = sink;
_setters = setters;
_ordinal = ordinal;
_lengthWritten = 0;
_metaData = metaData;
}
internal SmiGettersStream(SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData)
{
Debug.Assert(null != sink);
Debug.Assert(null != getters);
Debug.Assert(0 <= ordinal);
Debug.Assert(null != metaData);
_sink = sink;
_getters = getters;
_ordinal = ordinal;
_readPosition = 0;
_metaData = metaData;
}
internal SmiSettersStream(SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData)
{
Debug.Assert(null != sink);
Debug.Assert(null != setters);
Debug.Assert(0 <= ordinal);
Debug.Assert(null != metaData);
_sink = sink;
_setters = setters;
_ordinal = ordinal;
_lengthWritten = 0;
_metaData = metaData;
}
public virtual string GetString(int ordinal)
{
EnsureSubclassOverride();
SmiMetaData colMeta = GetSmiMetaData(ordinal);
if (_usesStringStorageForXml && SqlDbType.Xml == colMeta.SqlDbType)
{
return(ValueUtilsSmi.GetString(_eventSink, _recordBuffer, ordinal, s_maxNVarCharForXml));
}
else
{
return(ValueUtilsSmi.GetString(_eventSink, _recordBuffer, ordinal, GetSmiMetaData(ordinal)));
}
}
// Internal setter to be used by constructors only! Modifies state!
private void SetDefaultsForType(SqlDbType dbType)
{
SmiMetaData smdDflt = GetDefaultForType(dbType);
_databaseType = dbType;
_maxLength = smdDflt.MaxLength;
_precision = smdDflt.Precision;
_scale = smdDflt.Scale;
_localeId = smdDflt.LocaleId;
_compareOptions = smdDflt.CompareOptions;
_isMultiValued = smdDflt._isMultiValued;
_fieldMetaData = smdDflt._fieldMetaData; // This is ok due to immutability
_extendedProperties = smdDflt._extendedProperties; // This is ok due to immutability
}
private void SetDefaultsForType(System.Data.SqlDbType dbType)
{
SmiMetaData defaultForType = GetDefaultForType(dbType);
this._databaseType = dbType;
this._maxLength = defaultForType.MaxLength;
this._precision = defaultForType.Precision;
this._scale = defaultForType.Scale;
this._localeId = defaultForType.LocaleId;
this._compareOptions = defaultForType.CompareOptions;
this._clrType = null;
this._isMultiValued = defaultForType._isMultiValued;
this._fieldMetaData = defaultForType._fieldMetaData;
this._extendedProperties = defaultForType._extendedProperties;
}
private bool _isMetaSet; // flag to indicate whether we have set the variant metadata
internal SqlRecordBuffer(SmiMetaData metaData) {
_isNull = true;
}
// implements SqlClient 1.1-compatible GetSqlValue() semantics for everything except output parameters
internal static object GetSqlValue(
SmiEventSink_Default sink,
ITypedGettersV3 getters,
int ordinal,
SmiMetaData metaData,
SmiContext context
) {
object result = null;
if ( IsDBNull_Unchecked( sink, getters, ordinal ) ) {
if (SqlDbType.Udt == metaData.SqlDbType) {
result = NullUdtInstance(metaData);
}
else {
result = __typeSpecificNullForSqlValue[(int)metaData.SqlDbType];
}
}
else {
switch( metaData.SqlDbType ) {
case SqlDbType.BigInt:
result = new SqlInt64( GetInt64_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Binary:
result = GetSqlBinary_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.Bit:
result = new SqlBoolean( GetBoolean_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Char:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.DateTime:
result = new SqlDateTime( GetDateTime_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Decimal:
result = GetSqlDecimal_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.Float:
result = new SqlDouble( GetDouble_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Image:
result = GetSqlBinary_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.Int:
result = new SqlInt32( GetInt32_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Money:
result = GetSqlMoney_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.NChar:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.NText:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.NVarChar:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Real:
result = new SqlSingle( GetSingle_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.UniqueIdentifier:
result = new SqlGuid( GetGuid_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.SmallDateTime:
result = new SqlDateTime( GetDateTime_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.SmallInt:
result = new SqlInt16( GetInt16_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.SmallMoney:
result = GetSqlMoney_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.Text:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Timestamp:
result = GetSqlBinary_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.TinyInt:
result = new SqlByte( GetByte_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.VarBinary:
result = GetSqlBinary_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.VarChar:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Variant:
metaData = getters.GetVariantType( sink, ordinal );
sink.ProcessMessagesAndThrow();
Debug.Assert( SqlDbType.Variant != metaData.SqlDbType, "Variant-within-variant causes endless recursion!" );
result = GetSqlValue( sink, getters, ordinal, metaData, context );
break;
case SqlDbType.Xml:
result = GetSqlXml_Unchecked( sink, getters, ordinal, context );
break;
case SqlDbType.Udt:
result = GetUdt_LengthChecked( sink, getters, ordinal, metaData );
break;
}
}
return result;
}
internal static SmiExtendedMetaData SmiMetaDataFromSchemaTableRow(DataRow schemaRow)
{
string columnName = "";
object obj2 = schemaRow[SchemaTableColumn.ColumnName];
if (DBNull.Value != obj2)
{
columnName = (string)obj2;
}
obj2 = schemaRow[SchemaTableColumn.DataType];
if (DBNull.Value == obj2)
{
throw SQL.NullSchemaTableDataTypeNotSupported(columnName);
}
Type type2 = (Type)obj2;
SqlDbType dbType = InferSqlDbTypeFromType_Katmai(type2);
if (~SqlDbType.BigInt == dbType)
{
if (typeof(object) != type2)
{
throw SQL.UnsupportedColumnTypeForSqlProvider(columnName, type2.ToString());
}
dbType = SqlDbType.VarBinary;
}
long maxLength = 0L;
byte precision = 0;
byte scale = 0;
switch (dbType)
{
case SqlDbType.BigInt:
case SqlDbType.Bit:
case SqlDbType.DateTime:
case SqlDbType.Float:
case SqlDbType.Image:
case SqlDbType.Int:
case SqlDbType.Money:
case SqlDbType.NText:
case SqlDbType.Real:
case SqlDbType.UniqueIdentifier:
case SqlDbType.SmallDateTime:
case SqlDbType.SmallInt:
case SqlDbType.SmallMoney:
case SqlDbType.Text:
case SqlDbType.Timestamp:
case SqlDbType.TinyInt:
case SqlDbType.Variant:
case SqlDbType.Xml:
case SqlDbType.Date:
goto Label_0302;
case SqlDbType.Binary:
case SqlDbType.VarBinary:
obj2 = schemaRow[SchemaTableColumn.ColumnSize];
if (DBNull.Value != obj2)
{
maxLength = Convert.ToInt64(obj2, null);
if (maxLength > 0x1f40L)
{
maxLength = -1L;
}
if ((maxLength < 0L) && ((maxLength != -1L) || (SqlDbType.Binary == dbType)))
{
throw SQL.InvalidColumnMaxLength(columnName, maxLength);
}
}
else if (SqlDbType.Binary != dbType)
{
maxLength = -1L;
}
else
{
maxLength = 0x1f40L;
}
goto Label_0302;
case SqlDbType.Char:
case SqlDbType.VarChar:
obj2 = schemaRow[SchemaTableColumn.ColumnSize];
if (DBNull.Value != obj2)
{
maxLength = Convert.ToInt64(obj2, null);
if (maxLength > 0x1f40L)
{
maxLength = -1L;
}
if ((maxLength < 0L) && ((maxLength != -1L) || (SqlDbType.Char == dbType)))
{
throw SQL.InvalidColumnMaxLength(columnName, maxLength);
}
}
else if (SqlDbType.Char != dbType)
{
maxLength = -1L;
}
else
{
maxLength = 0x1f40L;
}
goto Label_0302;
case SqlDbType.Decimal:
obj2 = schemaRow[SchemaTableColumn.NumericPrecision];
if (DBNull.Value != obj2)
{
precision = Convert.ToByte(obj2, null);
break;
}
precision = SmiMetaData.DefaultDecimal.Precision;
break;
case SqlDbType.NChar:
case SqlDbType.NVarChar:
obj2 = schemaRow[SchemaTableColumn.ColumnSize];
if (DBNull.Value != obj2)
{
maxLength = Convert.ToInt64(obj2, null);
if (maxLength > 0xfa0L)
{
maxLength = -1L;
}
if ((maxLength < 0L) && ((maxLength != -1L) || (SqlDbType.NChar == dbType)))
{
throw SQL.InvalidColumnMaxLength(columnName, maxLength);
}
}
else if (SqlDbType.NChar != dbType)
{
maxLength = -1L;
}
else
{
maxLength = 0xfa0L;
}
goto Label_0302;
case SqlDbType.Time:
case SqlDbType.DateTime2:
case SqlDbType.DateTimeOffset:
obj2 = schemaRow[SchemaTableColumn.NumericScale];
if (DBNull.Value != obj2)
{
scale = Convert.ToByte(obj2, null);
}
else
{
scale = SmiMetaData.DefaultTime.Scale;
}
if (scale > 7)
{
throw SQL.InvalidColumnPrecScale();
}
if (scale < 0)
{
scale = SmiMetaData.DefaultTime.Scale;
}
goto Label_0302;
default:
throw SQL.UnsupportedColumnTypeForSqlProvider(columnName, type2.ToString());
}
obj2 = schemaRow[SchemaTableColumn.NumericScale];
if (DBNull.Value == obj2)
{
scale = SmiMetaData.DefaultDecimal.Scale;
}
else
{
scale = Convert.ToByte(obj2, null);
}
if (((precision < 1) || (precision > SqlDecimal.MaxPrecision)) || (((scale < 0) || (scale > SqlDecimal.MaxScale)) || (scale > precision)))
{
throw SQL.InvalidColumnPrecScale();
}
Label_0302:
return(new SmiExtendedMetaData(dbType, maxLength, precision, scale, (long)CultureInfo.CurrentCulture.LCID, SmiMetaData.GetDefaultForType(dbType).CompareOptions, null, false, null, null, columnName, null, null, null));
}
// calling GetTimeSpan on possibly v100 SMI
internal static TimeSpan GetTimeSpan(SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData, bool gettersSupportKatmaiDateTime) {
if (gettersSupportKatmaiDateTime) {
return GetTimeSpan(sink, (SmiTypedGetterSetter)getters, ordinal, metaData);
}
ThrowIfITypedGettersIsNull(sink, getters, ordinal);
object obj = GetValue(sink, getters, ordinal, metaData, null);
if (null == obj) {
throw ADP.InvalidCast();
}
return (TimeSpan) obj;
}
internal static Stream GetStream(SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData, bool bypassTypeCheck = false) {
bool isDbNull = ValueUtilsSmi.IsDBNull_Unchecked(sink, getters, ordinal);
// If a sql_variant, get the internal type
if ( !bypassTypeCheck ) {
if ((!isDbNull) && (metaData.SqlDbType == SqlDbType.Variant)) {
metaData = getters.GetVariantType(sink, ordinal);
}
// If the SqlDbType is still variant, then it must contain null, so don't throw InvalidCast
if ((metaData.SqlDbType != SqlDbType.Variant) && (!CanAccessGetterDirectly(metaData, ExtendedClrTypeCode.Stream))) {
throw ADP.InvalidCast();
}
}
byte[] data;
if (isDbNull) {
// "null" stream
data = new byte[0];
}
else {
// Read all data
data = GetByteArray_Unchecked(sink, getters, ordinal);
}
// Wrap data in pre-built object
return new MemoryStream(data, writable: false);
}
internal static SqlSequentialTextReaderSmi GetSequentialTextReader( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData ) {
Debug.Assert(!ValueUtilsSmi.IsDBNull_Unchecked(sink, getters, ordinal), "Should not try to get a SqlSequentialTextReaderSmi on a null column");
ThrowIfITypedGettersIsNull( sink, getters, ordinal );
if ( !CanAccessGetterDirectly( metaData, ExtendedClrTypeCode.TextReader ) ) {
throw ADP.InvalidCast();
}
// This will advance the column to ordinal
long length = GetCharsLength_Unchecked(sink, getters, ordinal);
return new SqlSequentialTextReaderSmi(sink, getters, ordinal, length);
}
internal static SqlXml GetSqlXml( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData, SmiContext context ) {
SqlXml result;
if ( CanAccessGetterDirectly( metaData, ExtendedClrTypeCode.SqlXml ) ) {
if ( IsDBNull_Unchecked( sink, getters, ordinal ) ) {
result = SqlXml.Null;
}
else {
result = GetSqlXml_Unchecked( sink, getters, ordinal, context );
}
}
else {
object obj = GetSqlValue( sink, getters, ordinal, metaData, null );
if (null == obj) {
throw ADP.InvalidCast();
}
result = (SqlXml) obj;
}
return result;
}
private bool _isMetaSet; // flag to indicate whether we have set the variant metadata
internal SqlRecordBuffer(SmiMetaData metaData)
{
_isNull = true;
}
internal static bool IsCompatible(SmiMetaData firstMd, SqlMetaData secondMd)
{
return(((((firstMd.SqlDbType == secondMd.SqlDbType) && (firstMd.MaxLength == secondMd.MaxLength)) && ((firstMd.Precision == secondMd.Precision) && (firstMd.Scale == secondMd.Scale))) && (((firstMd.CompareOptions == secondMd.CompareOptions) && (firstMd.LocaleId == secondMd.LocaleId)) && ((firstMd.Type == secondMd.Type) && (firstMd.SqlDbType != SqlDbType.Structured)))) && !firstMd.IsMultiValued);
}
// This is a modified version of SmiMetaDataFromSchemaTableRow above
// Since CoreCLR doesn't have GetSchema, we need to infer the MetaData from the CLR Type alone
internal static SmiExtendedMetaData SmiMetaDataFromType(string colName, Type colType)
{
// Determine correct SqlDbType.
SqlDbType colDbType = InferSqlDbTypeFromType_Katmai(colType);
if (InvalidSqlDbType == colDbType)
{
// Unknown through standard mapping, use VarBinary for columns that are Object typed, otherwise we error out.
if (typeof(object) == colType)
{
colDbType = SqlDbType.VarBinary;
}
else
{
throw SQL.UnsupportedColumnTypeForSqlProvider(colName, colType.ToString());
}
}
// Determine metadata modifier values per type (maxlength, precision, scale, etc)
long maxLength = 0;
byte precision = 0;
byte scale = 0;
switch (colDbType)
{
case SqlDbType.BigInt:
case SqlDbType.Bit:
case SqlDbType.DateTime:
case SqlDbType.Float:
case SqlDbType.Image:
case SqlDbType.Int:
case SqlDbType.Money:
case SqlDbType.NText:
case SqlDbType.Real:
case SqlDbType.UniqueIdentifier:
case SqlDbType.SmallDateTime:
case SqlDbType.SmallInt:
case SqlDbType.SmallMoney:
case SqlDbType.Text:
case SqlDbType.Timestamp:
case SqlDbType.TinyInt:
case SqlDbType.Variant:
case SqlDbType.Xml:
case SqlDbType.Date:
// These types require no metadata modifiers
break;
case SqlDbType.Binary:
case SqlDbType.VarBinary:
// source isn't specifying a size, so assume the Maximum
if (SqlDbType.Binary == colDbType)
{
maxLength = SmiMetaData.MaxBinaryLength;
}
else
{
maxLength = SmiMetaData.UnlimitedMaxLengthIndicator;
}
break;
case SqlDbType.Char:
case SqlDbType.VarChar:
// source isn't specifying a size, so assume the Maximum
if (SqlDbType.Char == colDbType)
{
maxLength = SmiMetaData.MaxANSICharacters;
}
else
{
maxLength = SmiMetaData.UnlimitedMaxLengthIndicator;
}
break;
case SqlDbType.NChar:
case SqlDbType.NVarChar:
// source isn't specifying a size, so assume the Maximum
if (SqlDbType.NChar == colDbType)
{
maxLength = SmiMetaData.MaxUnicodeCharacters;
}
else
{
maxLength = SmiMetaData.UnlimitedMaxLengthIndicator;
}
break;
case SqlDbType.Decimal:
// Decimal requires precision and scale
precision = SmiMetaData.DefaultDecimal.Precision;
scale = SmiMetaData.DefaultDecimal.Scale;
break;
case SqlDbType.Time:
case SqlDbType.DateTime2:
case SqlDbType.DateTimeOffset:
// requires scale
scale = SmiMetaData.DefaultTime.Scale;
break;
case SqlDbType.Udt:
case SqlDbType.Structured:
default:
// These types are not supported from SchemaTable
throw SQL.UnsupportedColumnTypeForSqlProvider(colName, colType.ToString());
}
return(new SmiExtendedMetaData(
colDbType,
maxLength,
precision,
scale,
CultureInfo.CurrentCulture.LCID,
SmiMetaData.GetDefaultForType(colDbType).CompareOptions,
false, // no support for multi-valued columns in a TVP yet
null, // no support for structured columns yet
null,
colName,
null,
null,
null));
}
// valid for SqlDbType.Variant
public override void SetVariantMetaData(SmiEventSink sink, int ordinal, SmiMetaData metaData)
{
_buffer[ordinal].VariantType = metaData;
}
internal static bool IsSetterAccessValid(SmiMetaData metaData, SmiXetterTypeCode xetterType)
{
return(__isSetterAccessValid[(int)metaData.SqlDbType, (int)xetterType]);
}
internal static SqlString GetSqlString( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData ) {
SqlString result;
if ( CanAccessGetterDirectly( metaData, ExtendedClrTypeCode.SqlString ) ) {
if ( IsDBNull_Unchecked( sink, getters, ordinal ) ) {
result = SqlString.Null;
}
else {
String temp = GetString_Unchecked( sink, getters, ordinal );
result = new SqlString( temp );
}
}
else if (SqlDbType.Xml == metaData.SqlDbType) {
SqlXml xmlValue = GetSqlXml_Unchecked( sink, getters, ordinal, null );
if (xmlValue.IsNull) {
result = SqlString.Null;
}
else {
result = new SqlString( xmlValue.Value );
}
}
else {
object obj = GetSqlValue( sink, getters, ordinal, metaData, null );
if (null == obj) {
throw ADP.InvalidCast();
}
result = (SqlString) obj;
}
return result;
}
private static void SetSqlMoney_Unchecked( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData, SqlMoney value ) {
if ( value.IsNull ) {
setters.SetDBNull( sink, ordinal );
}
else {
if ( SqlDbType.Variant == metaData.SqlDbType ) {
setters.SetVariantMetaData( sink, ordinal, SmiMetaData.DefaultMoney );
sink.ProcessMessagesAndThrow();
}
setters.SetInt64( sink, ordinal, value.ToSqlInternalRepresentation() );
}
sink.ProcessMessagesAndThrow();
}
internal static String GetString( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData ) {
ThrowIfITypedGettersIsNull( sink, getters, ordinal );
if ( CanAccessGetterDirectly( metaData, ExtendedClrTypeCode.String ) ) {
return GetString_Unchecked( sink, getters, ordinal );
}
object obj = GetValue( sink, getters, ordinal, metaData, null );
if (null == obj) {
throw ADP.InvalidCast();
}
return (String) obj;
}
private static void SetSqlString_Unchecked( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData, SqlString value, int offset, int length ) {
if ( value.IsNull ) {
setters.SetDBNull( sink, ordinal );
sink.ProcessMessagesAndThrow();
}
else {
if (SqlDbType.Variant == metaData.SqlDbType) {
// Set up a NVarChar metadata with correct LCID/Collation
metaData = new SmiMetaData(
SqlDbType.NVarChar,
SmiMetaData.MaxUnicodeCharacters,
0,
0,
value.LCID,
value.SqlCompareOptions,
null);
setters.SetVariantMetaData( sink, ordinal, metaData );
sink.ProcessMessagesAndThrow();
}
SetString_Unchecked( sink, setters, ordinal, value.Value, offset, length );
}
}
public virtual void SetVariantMetaData(SmiEventSink sink, int ordinal, SmiMetaData metaData)
{
throw ADP.InternalError(ADP.InternalErrorCode.UnimplementedSMIMethod);
}
private static void SetDataTable_Unchecked(
SmiEventSink_Default sink,
SmiTypedGetterSetter setters,
int ordinal,
SmiMetaData metaData,
DataTable value
) {
// Get the target gettersetter
setters = setters.GetTypedGetterSetter(sink, ordinal);
sink.ProcessMessagesAndThrow();
// iterate over all records
// if first record was obtained earlier, use it prior to pulling more
ExtendedClrTypeCode[] cellTypes = new ExtendedClrTypeCode[metaData.FieldMetaData.Count];
for(int i=0; i<metaData.FieldMetaData.Count; i++) {
cellTypes[i] = ExtendedClrTypeCode.Invalid;
}
foreach(DataRow row in value.Rows) {
setters.NewElement(sink);
sink.ProcessMessagesAndThrow();
// Set all columns in the record
for(int i=0; i<metaData.FieldMetaData.Count; i++) {
SmiMetaData fieldMetaData = metaData.FieldMetaData[i];
if (row.IsNull(i)) {
SetDBNull_Unchecked(sink, setters, i);
}
else {
object cellValue = row[i];
// Only determine cell types for first row, to save expensive
if (ExtendedClrTypeCode.Invalid == cellTypes[i]) {
cellTypes[i] = MetaDataUtilsSmi.DetermineExtendedTypeCodeForUseWithSqlDbType(
fieldMetaData.SqlDbType, fieldMetaData.IsMultiValued, cellValue, fieldMetaData.Type,
//
SmiContextFactory.KatmaiVersion
);
}
SetCompatibleValueV200(sink, setters, i, fieldMetaData, cellValue, cellTypes[i], 0, NoLengthLimit, null);
}
}
}
setters.EndElements(sink);
sink.ProcessMessagesAndThrow();
}
internal static TextReader GetTextReader( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData ) {
bool isDbNull = ValueUtilsSmi.IsDBNull_Unchecked(sink, getters, ordinal);
// If a sql_variant, get the internal type
if ((!isDbNull) && (metaData.SqlDbType == SqlDbType.Variant)) {
metaData = getters.GetVariantType(sink, ordinal);
}
// If the SqlDbType is still variant, then it must contain null, so don't throw InvalidCast
if ((metaData.SqlDbType != SqlDbType.Variant) && (!CanAccessGetterDirectly(metaData, ExtendedClrTypeCode.TextReader))) {
throw ADP.InvalidCast();
}
string data;
if (isDbNull) {
// "null" textreader
data = string.Empty;
}
else {
// Read all data
data = GetString_Unchecked(sink, getters, ordinal);
}
// Wrap in pre-built object
return new StringReader(data);
}
// Set a DbDataReader to a Structured+MultiValued setter (table type)
// Assumes metaData correctly describes the reader's shape, and consumes only the current resultset
private static void SetDbDataReader_Unchecked(
SmiEventSink_Default sink,
SmiTypedGetterSetter setters,
int ordinal,
SmiMetaData metaData,
DbDataReader value
) {
// Get the target gettersetter
setters = setters.GetTypedGetterSetter(sink, ordinal);
sink.ProcessMessagesAndThrow();
// Iterate over all rows in the current set of results
while (value.Read()) {
setters.NewElement(sink);
sink.ProcessMessagesAndThrow();
FillCompatibleSettersFromReader(sink, setters, metaData.FieldMetaData, value);
}
setters.EndElements(sink);
sink.ProcessMessagesAndThrow();
}
// dealing with v200 SMI
internal static TimeSpan GetTimeSpan(SmiEventSink_Default sink, SmiTypedGetterSetter getters, int ordinal, SmiMetaData metaData) {
ThrowIfITypedGettersIsNull(sink, getters, ordinal);
if (CanAccessGetterDirectly(metaData, ExtendedClrTypeCode.TimeSpan)) {
return GetTimeSpan_Unchecked(sink, getters, ordinal);
}
return (TimeSpan)GetValue200(sink, getters, ordinal, metaData, null);
}
private static void SetIEnumerableOfSqlDataRecord_Unchecked(
SmiEventSink_Default sink,
SmiTypedGetterSetter setters,
int ordinal,
SmiMetaData metaData,
IEnumerable<SqlDataRecord> value,
ParameterPeekAheadValue peekAhead
) {
// Get target gettersetter
setters = setters.GetTypedGetterSetter(sink, ordinal);
sink.ProcessMessagesAndThrow();
IEnumerator<SqlDataRecord> enumerator = null;
try {
// Need to copy field metadata to an array to call FillCompatibleITypeSettersFromRecord
SmiExtendedMetaData[] mdFields = new SmiExtendedMetaData[metaData.FieldMetaData.Count];
metaData.FieldMetaData.CopyTo(mdFields, 0);
SmiDefaultFieldsProperty defaults = (SmiDefaultFieldsProperty) metaData.ExtendedProperties[SmiPropertySelector.DefaultFields];
int recordNumber = 1; // used only for reporting position when there are errors.
// obtain enumerator and handle any peekahead values
if (null != peekAhead && null != peekAhead.FirstRecord) {
// hook up to enumerator
enumerator = peekAhead.Enumerator;
// send the first record that was obtained earlier
setters.NewElement(sink);
sink.ProcessMessagesAndThrow();
FillCompatibleSettersFromRecord(sink, setters, mdFields, peekAhead.FirstRecord, defaults);
recordNumber++;
}
else {
enumerator = value.GetEnumerator();
}
using (enumerator) {
while(enumerator.MoveNext()) {
setters.NewElement(sink);
sink.ProcessMessagesAndThrow();
SqlDataRecord record = enumerator.Current;
if (record.FieldCount != mdFields.Length) {
throw SQL.EnumeratedRecordFieldCountChanged(recordNumber);
}
for(int i=0; i<record.FieldCount; i++) {
if (!MetaDataUtilsSmi.IsCompatible(metaData.FieldMetaData[i], record.GetSqlMetaData(i))) {
throw SQL.EnumeratedRecordMetaDataChanged(record.GetName(i), recordNumber);
}
}
FillCompatibleSettersFromRecord(sink, setters, mdFields, record, defaults);
recordNumber++;
}
setters.EndElements(sink);
sink.ProcessMessagesAndThrow();
}
}
finally {
// Clean up!
IDisposable disposable = enumerator as IDisposable;
if (null != disposable) {
disposable.Dispose();
}
}
}
// dealing with v200 SMI
internal static object GetSqlValue200(
SmiEventSink_Default sink,
SmiTypedGetterSetter getters,
int ordinal,
SmiMetaData metaData,
SmiContext context
) {
object result = null;
if (IsDBNull_Unchecked(sink, getters, ordinal)) {
if (SqlDbType.Udt == metaData.SqlDbType) {
result = NullUdtInstance(metaData);
} else {
result = __typeSpecificNullForSqlValue[(int)metaData.SqlDbType];
}
} else {
switch (metaData.SqlDbType) {
case SqlDbType.Variant: // Handle variants specifically for v200, since they could contain v200 types
metaData = getters.GetVariantType(sink, ordinal);
sink.ProcessMessagesAndThrow();
Debug.Assert(SqlDbType.Variant != metaData.SqlDbType, "Variant-within-variant causes endless recursion!");
result = GetSqlValue200(sink, getters, ordinal, metaData, context);
break;
case SqlDbType.Date:
case SqlDbType.DateTime2:
result = GetDateTime_Unchecked(sink, getters, ordinal);
break;
case SqlDbType.Time:
result = GetTimeSpan_Unchecked(sink, getters, ordinal);
break;
case SqlDbType.DateTimeOffset:
result = GetDateTimeOffset_Unchecked(sink, getters, ordinal);
break;
default:
result = GetSqlValue(sink, getters, ordinal, metaData, context);
break;
}
}
return result;
}
internal static SqlChars GetSqlChars( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData, SmiContext context ) {
SqlChars result;
if ( CanAccessGetterDirectly( metaData, ExtendedClrTypeCode.SqlChars ) ) {
if ( IsDBNull_Unchecked( sink, getters, ordinal ) ) {
result = SqlChars.Null;
}
else {
long length = GetCharsLength_Unchecked( sink, getters, ordinal );
if ( length < __maxCharChunkSize || !InOutOfProcHelper.InProc) {
char[] charBuffer = GetCharArray_Unchecked( sink, getters, ordinal );
result = new SqlChars( charBuffer );
}
else { // InProc only
Stream s = new SmiGettersStream( sink, getters, ordinal, metaData );
SqlStreamChars sc = CopyIntoNewSmiScratchStreamChars( s, sink, context );
result = new SqlChars( sc );
}
}
}
else {
SqlString stringValue;
if (SqlDbType.Xml == metaData.SqlDbType) {
SqlXml xmlValue = GetSqlXml_Unchecked( sink, getters, ordinal, null );
if (xmlValue.IsNull) {
result = SqlChars.Null;
}
else {
result = new SqlChars( xmlValue.Value.ToCharArray() );
}
}
else {
object obj = GetSqlValue( sink, getters, ordinal, metaData, null );
if (null == obj) {
throw ADP.InvalidCast();
}
stringValue = (SqlString) obj;
if ( stringValue.IsNull ) {
result = SqlChars.Null;
}
else {
result = new SqlChars( stringValue.Value.ToCharArray() );
}
}
}
return result;
}
public virtual void SetVariantMetaData( SmiEventSink sink, int ordinal, SmiMetaData metaData ) {
// ******** OBSOLETING from SMI -- this should have been removed from ITypedSettersV3
// Intended to be removed prior to RTM. Sub-classes need not implement
// 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 );
}
internal static SqlSingle GetSqlSingle( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData ) {
SqlSingle result;
if ( CanAccessGetterDirectly( metaData, ExtendedClrTypeCode.SqlSingle ) ) {
if ( IsDBNull_Unchecked( sink, getters, ordinal ) ) {
result = SqlSingle.Null;
}
else {
Single temp = GetSingle_Unchecked( sink, getters, ordinal );
result = new SqlSingle( temp );
}
}
else {
object obj = GetSqlValue( sink, getters, ordinal, metaData, null );
if (null == obj) {
throw ADP.InvalidCast();
}
result = (SqlSingle) obj;
}
return result;
}
internal SqlRecordBuffer(SmiMetaData metaData)
{
}
// Map SmiMetaData from a schema table.
// DEVNOTE: Since we're using SchemaTable, we can assume that we aren't directly using a SqlDataReader
// so we don't support the Sql-specific stuff, like collation.
internal static SmiExtendedMetaData SmiMetaDataFromSchemaTableRow(DataRow schemaRow)
{
string colName = "";
object temp = schemaRow[SchemaTableColumn.ColumnName];
if (DBNull.Value != temp)
{
colName = (string)temp;
}
// Determine correct SqlDbType.
temp = schemaRow[SchemaTableColumn.DataType];
if (DBNull.Value == temp)
{
throw SQL.NullSchemaTableDataTypeNotSupported(colName);
}
Type colType = (Type)temp;
SqlDbType colDbType = InferSqlDbTypeFromType_Katmai(colType);
if (InvalidSqlDbType == colDbType)
{
// Unknown through standard mapping, use VarBinary for columns that are Object typed, otherwise error
if (typeof(object) == colType)
{
colDbType = SqlDbType.VarBinary;
}
else
{
throw SQL.UnsupportedColumnTypeForSqlProvider(colName, colType.ToString());
}
}
// Determine metadata modifier values per type (maxlength, precision, scale, etc)
long maxLength = 0;
byte precision = 0;
byte scale = 0;
switch (colDbType)
{
case SqlDbType.BigInt:
case SqlDbType.Bit:
case SqlDbType.DateTime:
case SqlDbType.Float:
case SqlDbType.Image:
case SqlDbType.Int:
case SqlDbType.Money:
case SqlDbType.NText:
case SqlDbType.Real:
case SqlDbType.UniqueIdentifier:
case SqlDbType.SmallDateTime:
case SqlDbType.SmallInt:
case SqlDbType.SmallMoney:
case SqlDbType.Text:
case SqlDbType.Timestamp:
case SqlDbType.TinyInt:
case SqlDbType.Variant:
case SqlDbType.Xml:
case SqlDbType.Date:
// These types require no metadata modifies
break;
case SqlDbType.Binary:
case SqlDbType.VarBinary:
// These types need a binary max length
temp = schemaRow[SchemaTableColumn.ColumnSize];
if (DBNull.Value == temp)
{
// source isn't specifying a size, so assume the worst
if (SqlDbType.Binary == colDbType)
{
maxLength = SmiMetaData.MaxBinaryLength;
}
else
{
maxLength = SmiMetaData.UnlimitedMaxLengthIndicator;
}
}
else
{
// We (should) have a valid maxlength, so use it.
maxLength = Convert.ToInt64(temp, null);
// Max length must be 0 to MaxBinaryLength or it can be UnlimitedMAX if type is varbinary.
// If it's greater than MaxBinaryLength, just promote it to UnlimitedMAX, if possible.
if (maxLength > SmiMetaData.MaxBinaryLength)
{
maxLength = SmiMetaData.UnlimitedMaxLengthIndicator;
}
if ((maxLength < 0 &&
(maxLength != SmiMetaData.UnlimitedMaxLengthIndicator ||
SqlDbType.Binary == colDbType)))
{
throw SQL.InvalidColumnMaxLength(colName, maxLength);
}
}
break;
case SqlDbType.Char:
case SqlDbType.VarChar:
// These types need an ANSI max length
temp = schemaRow[SchemaTableColumn.ColumnSize];
if (DBNull.Value == temp)
{
// source isn't specifying a size, so assume the worst
if (SqlDbType.Char == colDbType)
{
maxLength = SmiMetaData.MaxANSICharacters;
}
else
{
maxLength = SmiMetaData.UnlimitedMaxLengthIndicator;
}
}
else
{
// We (should) have a valid maxlength, so use it.
maxLength = Convert.ToInt64(temp, null);
// Max length must be 0 to MaxANSICharacters or it can be UnlimitedMAX if type is varbinary.
// If it's greater than MaxANSICharacters, just promote it to UnlimitedMAX, if possible.
if (maxLength > SmiMetaData.MaxANSICharacters)
{
maxLength = SmiMetaData.UnlimitedMaxLengthIndicator;
}
if ((maxLength < 0 &&
(maxLength != SmiMetaData.UnlimitedMaxLengthIndicator ||
SqlDbType.Char == colDbType)))
{
throw SQL.InvalidColumnMaxLength(colName, maxLength);
}
}
break;
case SqlDbType.NChar:
case SqlDbType.NVarChar:
// These types need a unicode max length
temp = schemaRow[SchemaTableColumn.ColumnSize];
if (DBNull.Value == temp)
{
// source isn't specifying a size, so assume the worst
if (SqlDbType.NChar == colDbType)
{
maxLength = SmiMetaData.MaxUnicodeCharacters;
}
else
{
maxLength = SmiMetaData.UnlimitedMaxLengthIndicator;
}
}
else
{
// We (should) have a valid maxlength, so use it.
maxLength = Convert.ToInt64(temp, null);
// Max length must be 0 to MaxUnicodeCharacters or it can be UnlimitedMAX if type is varbinary.
// If it's greater than MaxUnicodeCharacters, just promote it to UnlimitedMAX, if possible.
if (maxLength > SmiMetaData.MaxUnicodeCharacters)
{
maxLength = SmiMetaData.UnlimitedMaxLengthIndicator;
}
if ((maxLength < 0 &&
(maxLength != SmiMetaData.UnlimitedMaxLengthIndicator ||
SqlDbType.NChar == colDbType)))
{
throw SQL.InvalidColumnMaxLength(colName, maxLength);
}
}
break;
case SqlDbType.Decimal:
// Decimal requires precision and scale
temp = schemaRow[SchemaTableColumn.NumericPrecision];
if (DBNull.Value == temp)
{
precision = SmiMetaData.DefaultDecimal.Precision;
}
else
{
precision = Convert.ToByte(temp, null);
}
temp = schemaRow[SchemaTableColumn.NumericScale];
if (DBNull.Value == temp)
{
scale = SmiMetaData.DefaultDecimal.Scale;
}
else
{
scale = Convert.ToByte(temp, null);
}
if (precision < SmiMetaData.MinPrecision ||
precision > SqlDecimal.MaxPrecision ||
scale < SmiMetaData.MinScale ||
scale > SqlDecimal.MaxScale ||
scale > precision)
{
throw SQL.InvalidColumnPrecScale();
}
break;
case SqlDbType.Time:
case SqlDbType.DateTime2:
case SqlDbType.DateTimeOffset:
// requires scale
temp = schemaRow[SchemaTableColumn.NumericScale];
if (DBNull.Value == temp)
{
scale = SmiMetaData.DefaultTime.Scale;
}
else
{
scale = Convert.ToByte(temp, null);
}
if (scale > SmiMetaData.MaxTimeScale)
{
throw SQL.InvalidColumnPrecScale();
}
else if (scale < 0)
{
scale = SmiMetaData.DefaultTime.Scale;
}
break;
case SqlDbType.Udt:
case SqlDbType.Structured:
default:
// These types are not supported from SchemaTable
throw SQL.UnsupportedColumnTypeForSqlProvider(colName, colType.ToString());
}
return(new SmiExtendedMetaData(
colDbType,
maxLength,
precision,
scale,
System.Globalization.CultureInfo.CurrentCulture.LCID,
SmiMetaData.GetDefaultForType(colDbType).CompareOptions,
null, // no support for UDTs from SchemaTable
false, // no support for multi-valued columns in a TVP yet
null, // no support for structured columns yet
null, // no support for structured columns yet
colName,
null,
null,
null));
}
