internal override void ParameterAvailable(SmiParameterMetaData metaData, SmiTypedGetterSetter paramValue, int ordinal) { if (this._parent == null) { throw SQL.UnexpectedSmiEvent(UnexpectedEventType.ParameterAvailable); } this._parent.ParameterAvailable(metaData, paramValue, ordinal); }
internal virtual void RowAvailable(SmiTypedGetterSetter rowData) { // Adding as of V200 // 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 hasn't implemented V200 yet. // 2) Server didn't implement V200 on some interface, but negotiated V200+. System.Data.Common.ADP.InternalError( System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod ); }
internal virtual void RowAvailable(SmiTypedGetterSetter rowData) { // Adding as of V200 // 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 hasn't implemented V200 yet. // 2) Server didn't implement V200 on some interface, but negotiated V200+. System.Data.Common.ADP.InternalError(System.Data.Common.ADP.InternalErrorCode.UnimplementedSMIMethod); }
internal virtual void RowAvailable(SmiTypedGetterSetter rowData) { ADP.InternalError(ADP.InternalErrorCode.UnimplementedSMIMethod); }
private static TimeSpan GetTimeSpan_Unchecked(SmiEventSink_Default sink, SmiTypedGetterSetter getters, int ordinal) { TimeSpan timeSpan = getters.GetTimeSpan(sink, ordinal); sink.ProcessMessagesAndThrow(); return timeSpan; }
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(); }
private static TimeSpan GetTimeSpan_Unchecked(SmiEventSink_Default sink, SmiTypedGetterSetter getters, int ordinal) { Debug.Assert(!IsDBNull_Unchecked(sink, getters, ordinal)); TimeSpan result = getters.GetTimeSpan(sink, ordinal); sink.ProcessMessagesAndThrow(); return result; }
// Use chunking via SetChars to transfer a value from a reader to a gettersetter private static void SetChars_FromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DbDataReader reader, int offset) { int length = 0; // Deal with large values by sending bufferLength of NoLengthLimit (== assume // CheckXetParameters will ignore requested-length checks in this case) length = CheckXetParameters(metaData.SqlDbType, metaData.MaxLength, NoLengthLimit /* actual */, 0, NoLengthLimit /* buffer length */, offset, NoLengthLimit /* requested length */ ); // Use fixed chunk size for all cases to avoid inquiring from reader. int chunkSize; if (MetaDataUtilsSmi.IsAnsiType(metaData.SqlDbType)) { chunkSize = __maxByteChunkSize; } else { chunkSize = __maxCharChunkSize; } char[] buffer = new char[ chunkSize ]; long charsRead; long charsWritten = 1; // prime value to get into write loop long currentOffset = offset; long lengthWritten = 0; while ((length < 0 || lengthWritten < length) && 0 != (charsRead = reader.GetChars(ordinal, currentOffset, buffer, 0, chunkSize)) && 0 != charsWritten) { charsWritten = setters.SetChars(sink, ordinal, currentOffset, buffer, 0, checked((int) charsRead)); sink.ProcessMessagesAndThrow(); checked{ currentOffset += charsWritten; } checked{ lengthWritten += charsWritten; } } // Make sure to trim any left-over data (remember to trim at end of offset, not just the amount written setters.SetCharsLength(sink, ordinal, currentOffset); sink.ProcessMessagesAndThrow(); }
private static void SetTimeSpan_Checked(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, TimeSpan value) { VerifyTimeRange(metaData.SqlDbType, value); SetTimeSpan_Unchecked(sink, setters, ordinal, value); }
// Copy multiple fields from reader to SmiTypedGetterSetter // Supports V200 code path, without damaging backward compat for V100 code. // Main differences are supporting DbDataReader, and for binary, character, decimal and Udt types. // Assumes caller enforces that reader and setter metadata are compatible internal static void FillCompatibleSettersFromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, IList<SmiExtendedMetaData> metaData, DbDataReader reader) { for (int i = 0; i < metaData.Count; i++) { if (reader.IsDBNull(i)) { ValueUtilsSmi.SetDBNull_Unchecked(sink, setters, i); } else { switch (metaData[i].SqlDbType) { case SqlDbType.BigInt: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Int64)); SetInt64_Unchecked(sink, setters, i, reader.GetInt64(i)); break; case SqlDbType.Binary: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.ByteArray)); SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); break; case SqlDbType.Bit: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Boolean)); SetBoolean_Unchecked(sink, setters, i, reader.GetBoolean(i)); break; case SqlDbType.Char: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.CharArray)); SetCharsOrString_FromReader(sink, setters, i, metaData[i], reader, 0); break; case SqlDbType.DateTime: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.DateTime)); SetDateTime_Checked(sink, setters, i, metaData[i], reader.GetDateTime(i)); break; case SqlDbType.Decimal: { // block to scope sqlReader local to avoid conflicts Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlDecimal)); // Support full fidelity for SqlDataReader SqlDataReader sqlReader = reader as SqlDataReader; if (null != sqlReader) { SetSqlDecimal_Unchecked(sink, setters, i, sqlReader.GetSqlDecimal(i)); } else { SetSqlDecimal_Unchecked(sink, setters, i, new SqlDecimal(reader.GetDecimal(i))); } } break; case SqlDbType.Float: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Double)); SetDouble_Unchecked(sink, setters, i, reader.GetDouble(i)); break; case SqlDbType.Image: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.ByteArray)); SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); break; case SqlDbType.Int: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Int32)); SetInt32_Unchecked(sink, setters, i, reader.GetInt32(i)); break; case SqlDbType.Money: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlMoney)); SetSqlMoney_Checked(sink, setters, i, metaData[i], new SqlMoney(reader.GetDecimal(i))); break; case SqlDbType.NChar: case SqlDbType.NText: case SqlDbType.NVarChar: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.CharArray)); SetCharsOrString_FromReader(sink, setters, i, metaData[i], reader, 0); break; case SqlDbType.Real: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Single)); SetSingle_Unchecked(sink, setters, i, reader.GetFloat(i)); break; case SqlDbType.UniqueIdentifier: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Guid)); SetGuid_Unchecked(sink, setters, i, reader.GetGuid(i)); break; case SqlDbType.SmallDateTime: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.DateTime)); SetDateTime_Checked(sink, setters, i,metaData[i], reader.GetDateTime(i)); break; case SqlDbType.SmallInt: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Int16)); SetInt16_Unchecked(sink, setters, i, reader.GetInt16(i)); break; case SqlDbType.SmallMoney: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlMoney)); SetSqlMoney_Checked(sink, setters, i, metaData[i], new SqlMoney(reader.GetDecimal(i))); break; case SqlDbType.Text: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.CharArray)); SetCharsOrString_FromReader(sink, setters, i, metaData[i], reader, 0); break; case SqlDbType.Timestamp: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.ByteArray)); SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); break; case SqlDbType.TinyInt: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Byte)); SetByte_Unchecked(sink, setters, i, reader.GetByte(i)); break; case SqlDbType.VarBinary: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.ByteArray)); SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); break; case SqlDbType.VarChar: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.String)); SetCharsOrString_FromReader(sink, setters, i, metaData[i], reader, 0); break; case SqlDbType.Xml: { Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlXml)); SqlDataReader sqlReader = reader as SqlDataReader; if (null != sqlReader) { SetSqlXml_Unchecked(sink, setters, i, sqlReader.GetSqlXml(i)); } else { SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); } } break; case SqlDbType.Variant: { // block to scope sqlReader local and avoid conflicts // Support better options for SqlDataReader SqlDataReader sqlReader = reader as SqlDataReader; SqlBuffer.StorageType storageType = SqlBuffer.StorageType.Empty; object o; if (null != sqlReader) { o = sqlReader.GetSqlValue(i); storageType = sqlReader.GetVariantInternalStorageType(i); } else { o = reader.GetValue(i); } ExtendedClrTypeCode typeCode = MetaDataUtilsSmi.DetermineExtendedTypeCodeForUseWithSqlDbType(metaData[i].SqlDbType, metaData[i].IsMultiValued, o, null, // SmiContextFactory.KatmaiVersion ); if ((storageType == SqlBuffer.StorageType.DateTime2) || (storageType == SqlBuffer.StorageType.Date)) SetCompatibleValueV200(sink, setters, i, metaData[i], o, typeCode, 0, 0, null, storageType); else SetCompatibleValueV200(sink, setters, i, metaData[i], o, typeCode, 0, 0, null); } break; case SqlDbType.Udt: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.ByteArray)); // Skip serialization for Udt types. SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); break; // SqlDbType.Structured should have been caught before this point for TVPs. SUDTs will still need to implement. case SqlDbType.Date: case SqlDbType.DateTime2: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.DateTime)); SetDateTime_Checked(sink, setters, i, metaData[i], reader.GetDateTime(i)); break; case SqlDbType.Time: { // block to scope sqlReader local and avoid conflicts Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.TimeSpan)); SqlDataReader sqlReader = reader as SqlDataReader; TimeSpan ts; if (null != sqlReader) { ts = sqlReader.GetTimeSpan(i); } else { ts = (TimeSpan)reader.GetValue(i); } SetTimeSpan_Checked(sink, setters, i, metaData[i], ts); } break; case SqlDbType.DateTimeOffset: { // block to scope sqlReader local and avoid conflicts Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.DateTimeOffset)); SqlDataReader sqlReader = reader as SqlDataReader; DateTimeOffset dto; if (null != sqlReader) { dto = sqlReader.GetDateTimeOffset(i); } else { dto = (DateTimeOffset)reader.GetValue(i); } SetDateTimeOffset_Unchecked(sink, setters, i, dto); } break; default: // In order for us to get here we would have to have an // invalid instance of SqlDbType, or one would have to add // new member to SqlDbType without adding a case in this // switch, hence the assert - it must be Debug.Assert(false, "unsupported DbType:" + metaData[i].SqlDbType.ToString()); throw ADP.NotSupported(); } } } }
private static void SetString_FromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DbDataReader reader, int offset) { string str = reader.GetString(ordinal); int length = CheckXetParameters(metaData.SqlDbType, metaData.MaxLength, (long) str.Length, 0L, -1, offset, -1); setters.SetString(sink, ordinal, str, offset, length); sink.ProcessMessagesAndThrow(); }
private static void SetIEnumerableOfSqlDataRecord_Unchecked(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, IEnumerable<SqlDataRecord> value, ParameterPeekAheadValue peekAhead) { setters = setters.GetTypedGetterSetter(sink, ordinal); sink.ProcessMessagesAndThrow(); IEnumerator<SqlDataRecord> enumerator = null; try { SmiExtendedMetaData[] array = new SmiExtendedMetaData[metaData.FieldMetaData.Count]; metaData.FieldMetaData.CopyTo(array, 0); SmiDefaultFieldsProperty useDefaultValues = (SmiDefaultFieldsProperty) metaData.ExtendedProperties[SmiPropertySelector.DefaultFields]; int recordNumber = 1; if ((peekAhead != null) && (peekAhead.FirstRecord != null)) { enumerator = peekAhead.Enumerator; setters.NewElement(sink); sink.ProcessMessagesAndThrow(); FillCompatibleSettersFromRecord(sink, setters, array, peekAhead.FirstRecord, useDefaultValues); recordNumber++; } else { enumerator = value.GetEnumerator(); } using (enumerator) { while (enumerator.MoveNext()) { setters.NewElement(sink); sink.ProcessMessagesAndThrow(); SqlDataRecord current = enumerator.Current; if (current.FieldCount != array.Length) { throw SQL.EnumeratedRecordFieldCountChanged(recordNumber); } for (int i = 0; i < current.FieldCount; i++) { if (!MetaDataUtilsSmi.IsCompatible(metaData.FieldMetaData[i], current.GetSqlMetaData(i))) { throw SQL.EnumeratedRecordMetaDataChanged(current.GetName(i), recordNumber); } } FillCompatibleSettersFromRecord(sink, setters, array, current, useDefaultValues); recordNumber++; } setters.EndElements(sink); sink.ProcessMessagesAndThrow(); } } finally { IDisposable disposable = enumerator; if (disposable != null) { disposable.Dispose(); } } }
private static void SetDataTable_Unchecked(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DataTable value) { setters = setters.GetTypedGetterSetter(sink, ordinal); sink.ProcessMessagesAndThrow(); ExtendedClrTypeCode[] codeArray = new ExtendedClrTypeCode[metaData.FieldMetaData.Count]; for (int i = 0; i < metaData.FieldMetaData.Count; i++) { codeArray[i] = ExtendedClrTypeCode.Invalid; } foreach (DataRow row in value.Rows) { setters.NewElement(sink); sink.ProcessMessagesAndThrow(); for (int j = 0; j < metaData.FieldMetaData.Count; j++) { SmiMetaData data = metaData.FieldMetaData[j]; if (row.IsNull(j)) { SetDBNull_Unchecked(sink, setters, j); } else { object obj2 = row[j]; if (ExtendedClrTypeCode.Invalid == codeArray[j]) { codeArray[j] = MetaDataUtilsSmi.DetermineExtendedTypeCodeForUseWithSqlDbType(data.SqlDbType, data.IsMultiValued, obj2, data.Type, 210L); } SetCompatibleValueV200(sink, setters, j, data, obj2, codeArray[j], 0, -1, null); } } } setters.EndElements(sink); sink.ProcessMessagesAndThrow(); }
internal static void SetCompatibleValueV200(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, object value, ExtendedClrTypeCode typeCode, int offset, int length, ParameterPeekAheadValue peekAhead) { switch (typeCode) { case ExtendedClrTypeCode.DataTable: SetDataTable_Unchecked(sink, setters, ordinal, metaData, (DataTable) value); return; case ExtendedClrTypeCode.DbDataReader: SetDbDataReader_Unchecked(sink, setters, ordinal, metaData, (DbDataReader) value); return; case ExtendedClrTypeCode.IEnumerableOfSqlDataRecord: SetIEnumerableOfSqlDataRecord_Unchecked(sink, setters, ordinal, metaData, (IEnumerable<SqlDataRecord>) value, peekAhead); return; case ExtendedClrTypeCode.TimeSpan: SetTimeSpan_Checked(sink, setters, ordinal, metaData, (TimeSpan) value); return; case ExtendedClrTypeCode.DateTimeOffset: SetDateTimeOffset_Unchecked(sink, setters, ordinal, (DateTimeOffset) value); return; } SetCompatibleValue(sink, setters, ordinal, metaData, value, typeCode, offset); }
private static void SetChars_FromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DbDataReader reader, int offset) { int num4; long num6; int num5 = 0; num5 = CheckXetParameters(metaData.SqlDbType, metaData.MaxLength, -1L, 0L, -1, offset, -1); if (MetaDataUtilsSmi.IsAnsiType(metaData.SqlDbType)) { num4 = 0x1f40; } else { num4 = 0xfa0; } char[] buffer = new char[num4]; long num2 = 1L; long dataOffset = offset; for (long i = 0L; ((num5 < 0) || (i < num5)) && ((0L != (num6 = reader.GetChars(ordinal, dataOffset, buffer, 0, num4))) && (0L != num2)); i += num2) { num2 = setters.SetChars(sink, ordinal, dataOffset, buffer, 0, (int) num6); sink.ProcessMessagesAndThrow(); dataOffset += num2; } setters.SetCharsLength(sink, ordinal, dataOffset); sink.ProcessMessagesAndThrow(); }
private static void SetBytes_FromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DbDataReader reader, int offset) { long num6; int num4 = 0; num4 = CheckXetParameters(metaData.SqlDbType, metaData.MaxLength, -1L, 0L, -1, offset, -1); int length = 0x1f40; byte[] buffer = new byte[length]; long num2 = 1L; long dataOffset = offset; for (long i = 0L; ((num4 < 0) || (i < num4)) && ((0L != (num6 = reader.GetBytes(ordinal, dataOffset, buffer, 0, length))) && (0L != num2)); i += num2) { num2 = setters.SetBytes(sink, ordinal, dataOffset, buffer, 0, (int) num6); sink.ProcessMessagesAndThrow(); dataOffset += num2; } setters.SetBytesLength(sink, ordinal, dataOffset); sink.ProcessMessagesAndThrow(); }
internal static object GetValue200(SmiEventSink_Default sink, SmiTypedGetterSetter getters, int ordinal, SmiMetaData metaData, SmiContext context) { if (IsDBNull_Unchecked(sink, getters, ordinal)) { return DBNull.Value; } switch (metaData.SqlDbType) { case SqlDbType.Date: case SqlDbType.DateTime2: return GetDateTime_Unchecked(sink, getters, ordinal); case SqlDbType.Time: return GetTimeSpan_Unchecked(sink, getters, ordinal); case SqlDbType.DateTimeOffset: return GetDateTimeOffset_Unchecked(sink, getters, ordinal); case SqlDbType.Variant: metaData = getters.GetVariantType(sink, ordinal); sink.ProcessMessagesAndThrow(); return GetValue200(sink, getters, ordinal, metaData, context); } return GetValue(sink, getters, ordinal, metaData, context); }
// VSTFDevDiv#479681 - Data corruption when sending Katmai Date types to the server via TVP // Ensures proper handling on DateTime2 sub type for Sql_Variants and TVPs. internal static void SetCompatibleValueV200( SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, object value, ExtendedClrTypeCode typeCode, int offset, int length, ParameterPeekAheadValue peekAhead, SqlBuffer.StorageType storageType ) { // Ensure caller validated compatibility for types handled directly in this method Debug.Assert((ExtendedClrTypeCode.DataTable != typeCode && ExtendedClrTypeCode.DbDataReader != typeCode && ExtendedClrTypeCode.IEnumerableOfSqlDataRecord != typeCode) || CanAccessSetterDirectly(metaData, typeCode), "Un-validated type '" + typeCode + "' for metaData: " + metaData.SqlDbType); if (typeCode == ExtendedClrTypeCode.DateTime) { if (storageType == SqlBuffer.StorageType.DateTime2) SetDateTime2_Checked(sink, setters, ordinal, metaData, (DateTime)value); else if (storageType == SqlBuffer.StorageType.Date) SetDate_Checked(sink, setters, ordinal, metaData, (DateTime)value); else SetDateTime_Checked(sink, setters, ordinal, metaData, (DateTime)value); } else { SetCompatibleValueV200(sink, setters, ordinal, metaData, value, typeCode, offset, length, peekAhead); } }
// Implements SqlClient 2.0-compatible SetValue() semantics + Orcas extensions // Assumes caller already validated basic type against the metadata, other than trimming lengths and // checking individual field values (TVPs) internal static void SetCompatibleValueV200( SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, object value, ExtendedClrTypeCode typeCode, int offset, int length, ParameterPeekAheadValue peekAhead ) { // Ensure caller validated compatibility for types handled directly in this method Debug.Assert( (ExtendedClrTypeCode.DataTable != typeCode && ExtendedClrTypeCode.DbDataReader != typeCode && ExtendedClrTypeCode.IEnumerableOfSqlDataRecord != typeCode) || CanAccessSetterDirectly(metaData, typeCode), "Un-validated type '" + typeCode + "' for metaData: " + metaData.SqlDbType); switch(typeCode) { case ExtendedClrTypeCode.DataTable: SetDataTable_Unchecked(sink, setters, ordinal, metaData, (DataTable)value); break; case ExtendedClrTypeCode.DbDataReader: SetDbDataReader_Unchecked(sink, setters, ordinal, metaData, (DbDataReader)value); break; case ExtendedClrTypeCode.IEnumerableOfSqlDataRecord: SetIEnumerableOfSqlDataRecord_Unchecked(sink, setters, ordinal, metaData, (IEnumerable<SqlDataRecord>)value, peekAhead); break; case ExtendedClrTypeCode.TimeSpan: SetTimeSpan_Checked(sink, setters, ordinal, metaData, (TimeSpan)value); break; case ExtendedClrTypeCode.DateTimeOffset: SetDateTimeOffset_Unchecked(sink, setters, ordinal, (DateTimeOffset)value); break; default: SetCompatibleValue(sink, setters, ordinal, metaData, value, typeCode, offset); break; } }
internal static void FillCompatibleSettersFromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, IList<SmiExtendedMetaData> metaData, DbDataReader reader) { for (int i = 0; i < metaData.Count; i++) { object sqlValue; DateTimeOffset dateTimeOffset; TimeSpan timeSpan; ExtendedClrTypeCode code; if (reader.IsDBNull(i)) { SetDBNull_Unchecked(sink, setters, i); continue; } switch (metaData[i].SqlDbType) { case SqlDbType.BigInt: { SetInt64_Unchecked(sink, setters, i, reader.GetInt64(i)); continue; } case SqlDbType.Binary: { SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); continue; } case SqlDbType.Bit: { SetBoolean_Unchecked(sink, setters, i, reader.GetBoolean(i)); continue; } case SqlDbType.Char: { SetCharsOrString_FromReader(sink, setters, i, metaData[i], reader, 0); continue; } case SqlDbType.DateTime: { SetDateTime_Checked(sink, setters, i, metaData[i], reader.GetDateTime(i)); continue; } case SqlDbType.Decimal: { SqlDataReader reader6 = reader as SqlDataReader; if (reader6 == null) { break; } SetSqlDecimal_Unchecked(sink, setters, i, reader6.GetSqlDecimal(i)); continue; } case SqlDbType.Float: { SetDouble_Unchecked(sink, setters, i, reader.GetDouble(i)); continue; } case SqlDbType.Image: { SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); continue; } case SqlDbType.Int: { SetInt32_Unchecked(sink, setters, i, reader.GetInt32(i)); continue; } case SqlDbType.Money: { SetSqlMoney_Checked(sink, setters, i, metaData[i], new SqlMoney(reader.GetDecimal(i))); continue; } case SqlDbType.NChar: case SqlDbType.NText: case SqlDbType.NVarChar: { SetCharsOrString_FromReader(sink, setters, i, metaData[i], reader, 0); continue; } case SqlDbType.Real: { SetSingle_Unchecked(sink, setters, i, reader.GetFloat(i)); continue; } case SqlDbType.UniqueIdentifier: { SetGuid_Unchecked(sink, setters, i, reader.GetGuid(i)); continue; } case SqlDbType.SmallDateTime: { SetDateTime_Checked(sink, setters, i, metaData[i], reader.GetDateTime(i)); continue; } case SqlDbType.SmallInt: { SetInt16_Unchecked(sink, setters, i, reader.GetInt16(i)); continue; } case SqlDbType.SmallMoney: { SetSqlMoney_Checked(sink, setters, i, metaData[i], new SqlMoney(reader.GetDecimal(i))); continue; } case SqlDbType.Text: { SetCharsOrString_FromReader(sink, setters, i, metaData[i], reader, 0); continue; } case SqlDbType.Timestamp: { SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); continue; } case SqlDbType.TinyInt: { SetByte_Unchecked(sink, setters, i, reader.GetByte(i)); continue; } case SqlDbType.VarBinary: { SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); continue; } case SqlDbType.VarChar: { SetCharsOrString_FromReader(sink, setters, i, metaData[i], reader, 0); continue; } case SqlDbType.Variant: { SqlDataReader reader4 = reader as SqlDataReader; if (reader4 == null) { goto Label_0311; } sqlValue = reader4.GetSqlValue(i); goto Label_0319; } case SqlDbType.Xml: { SqlDataReader reader5 = reader as SqlDataReader; if (reader5 == null) { goto Label_02E4; } SetSqlXml_Unchecked(sink, setters, i, reader5.GetSqlXml(i)); continue; } case SqlDbType.Udt: { SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); continue; } case SqlDbType.Date: case SqlDbType.DateTime2: { SetDateTime_Checked(sink, setters, i, metaData[i], reader.GetDateTime(i)); continue; } case SqlDbType.Time: { SqlDataReader reader3 = reader as SqlDataReader; if (reader3 == null) { goto Label_03A0; } timeSpan = reader3.GetTimeSpan(i); goto Label_03AE; } case SqlDbType.DateTimeOffset: { SqlDataReader reader2 = reader as SqlDataReader; if (reader2 == null) { goto Label_03D5; } dateTimeOffset = reader2.GetDateTimeOffset(i); goto Label_03E2; } default: throw ADP.NotSupported(); } SetSqlDecimal_Unchecked(sink, setters, i, new SqlDecimal(reader.GetDecimal(i))); continue; Label_02E4: SetBytes_FromReader(sink, setters, i, metaData[i], reader, 0); continue; Label_0311: sqlValue = reader.GetValue(i); Label_0319: code = MetaDataUtilsSmi.DetermineExtendedTypeCodeForUseWithSqlDbType(metaData[i].SqlDbType, metaData[i].IsMultiValued, sqlValue, null, 210L); SetCompatibleValueV200(sink, setters, i, metaData[i], sqlValue, code, 0, 0, null); continue; Label_03A0: timeSpan = (TimeSpan) reader.GetValue(i); Label_03AE: SetTimeSpan_Checked(sink, setters, i, metaData[i], timeSpan); continue; Label_03D5: dateTimeOffset = (DateTimeOffset) reader.GetValue(i); Label_03E2: SetDateTimeOffset_Unchecked(sink, setters, i, dateTimeOffset); } }
internal static void FillCompatibleSettersFromRecord(SmiEventSink_Default sink, SmiTypedGetterSetter setters, SmiMetaData[] metaData, SqlDataRecord record, SmiDefaultFieldsProperty useDefaultValues) { for (int i = 0; i < metaData.Length; ++i) { if (null != useDefaultValues && useDefaultValues[i]) { continue; } if (record.IsDBNull(i)) { ValueUtilsSmi.SetDBNull_Unchecked(sink, setters, i); } else { switch (metaData[i].SqlDbType) { case SqlDbType.BigInt: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Int64)); SetInt64_Unchecked(sink, setters, i, record.GetInt64(i)); break; case SqlDbType.Binary: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlBytes)); SetBytes_FromRecord(sink, setters, i, metaData[i], record, 0); break; case SqlDbType.Bit: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Boolean)); SetBoolean_Unchecked(sink, setters, i, record.GetBoolean(i)); break; case SqlDbType.Char: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlChars)); SetChars_FromRecord(sink, setters, i, metaData[i], record, 0); break; case SqlDbType.DateTime: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.DateTime)); SetDateTime_Checked(sink, setters, i, metaData[i], record.GetDateTime(i)); break; case SqlDbType.Decimal: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlDecimal)); SetSqlDecimal_Unchecked(sink, setters, i, record.GetSqlDecimal(i)); break; case SqlDbType.Float: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Double)); SetDouble_Unchecked(sink, setters, i, record.GetDouble(i)); break; case SqlDbType.Image: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlBytes)); SetBytes_FromRecord(sink, setters, i, metaData[i], record, 0); break; case SqlDbType.Int: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Int32)); SetInt32_Unchecked(sink, setters, i, record.GetInt32(i)); break; case SqlDbType.Money: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlMoney)); SetSqlMoney_Unchecked(sink, setters, i, metaData[i], record.GetSqlMoney(i)); break; case SqlDbType.NChar: case SqlDbType.NText: case SqlDbType.NVarChar: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlChars)); SetChars_FromRecord(sink, setters, i, metaData[i], record, 0); break; case SqlDbType.Real: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Single)); SetSingle_Unchecked(sink, setters, i, record.GetFloat(i)); break; case SqlDbType.UniqueIdentifier: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Guid)); SetGuid_Unchecked(sink, setters, i, record.GetGuid(i)); break; case SqlDbType.SmallDateTime: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.DateTime)); SetDateTime_Checked(sink, setters, i, metaData[i], record.GetDateTime(i)); break; case SqlDbType.SmallInt: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Int16)); SetInt16_Unchecked(sink, setters, i, record.GetInt16(i)); break; case SqlDbType.SmallMoney: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlMoney)); SetSqlMoney_Checked(sink, setters, i, metaData[i], record.GetSqlMoney(i)); break; case SqlDbType.Text: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlChars)); SetChars_FromRecord(sink, setters, i, metaData[i], record, 0); break; case SqlDbType.Timestamp: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlBytes)); SetBytes_FromRecord(sink, setters, i, metaData[i], record, 0); break; case SqlDbType.TinyInt: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.Byte)); SetByte_Unchecked(sink, setters, i, record.GetByte(i)); break; case SqlDbType.VarBinary: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlBytes)); SetBytes_FromRecord(sink, setters, i, metaData[i], record, 0); break; case SqlDbType.VarChar: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.String)); SetChars_FromRecord(sink, setters, i, metaData[i], record, 0); break; case SqlDbType.Xml: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlXml)); SetSqlXml_Unchecked(sink, setters, i, record.GetSqlXml(i)); // perf improvement? break; case SqlDbType.Variant: object o = record.GetSqlValue(i); ExtendedClrTypeCode typeCode = MetaDataUtilsSmi.DetermineExtendedTypeCode(o); SetCompatibleValueV200(sink, setters, i, metaData[i], o, typeCode, 0, -1 /* no length restriction */, null /* no peekahead */); break; case SqlDbType.Udt: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.SqlBytes)); SetBytes_FromRecord(sink, setters, i, metaData[i], record, 0); break; case SqlDbType.Date: case SqlDbType.DateTime2: Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.DateTime)); SetDateTime_Checked(sink, setters, i, metaData[i], record.GetDateTime(i)); break; case SqlDbType.Time: { // block to scope sqlReader local and avoid conflicts Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.TimeSpan)); SqlDataRecord sqlRecord = record as SqlDataRecord; TimeSpan ts; if (null != sqlRecord) { ts = sqlRecord.GetTimeSpan(i); } else { ts = (TimeSpan)record.GetValue(i); } SetTimeSpan_Checked(sink, setters, i, metaData[i], ts); } break; case SqlDbType.DateTimeOffset: { // block to scope sqlReader local and avoid conflicts Debug.Assert(CanAccessSetterDirectly(metaData[i], ExtendedClrTypeCode.DateTimeOffset)); SqlDataRecord sqlRecord = record as SqlDataRecord; DateTimeOffset dto; if (null != sqlRecord) { dto = sqlRecord.GetDateTimeOffset(i); } else { dto = (DateTimeOffset)record.GetValue(i); } SetDateTimeOffset_Unchecked(sink, setters, i, dto); } break; default: Debug.Assert(false, "unsupported DbType:" + metaData[i].SqlDbType.ToString()); throw ADP.NotSupported(); } } } }
// dealing with v200 SMI internal static DateTimeOffset GetDateTimeOffset(SmiEventSink_Default sink, SmiTypedGetterSetter getters, int ordinal, SmiMetaData metaData) { ThrowIfITypedGettersIsNull(sink, getters, ordinal); if (CanAccessGetterDirectly(metaData, ExtendedClrTypeCode.DateTimeOffset)) { return GetDateTimeOffset_Unchecked(sink, getters, ordinal); } return (DateTimeOffset)GetValue200(sink, getters, ordinal, metaData); }
// Transfer a character value from a reader when we're not sure which GetXXX method the reader will support. // Prefers to chunk data via GetChars, but falls back to GetString if that fails. // Mainly put in place because DataTableReader doesn't support GetChars on string columns, but others could fail too... private static void SetCharsOrString_FromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DbDataReader reader, int offset) { bool success = false; try { SetChars_FromReader(sink, setters, ordinal, metaData, reader, offset); success = true; } catch(Exception e) { if (!ADP.IsCatchableExceptionType(e)) { throw; } } if (!success) { SetString_FromReader(sink, setters, ordinal, metaData, reader, offset); } }
internal override void ParameterAvailable(SmiParameterMetaData metaData, SmiTypedGetterSetter parameterValues, int ordinal) { if (Bid.AdvancedOn && (metaData != null)) { Bid.Trace("<sc.SqlCommand.CommandEventSink.ParameterAvailable|ADV> %d#, metaData[%d] is %ls%ls\n", this._command.ObjectID, ordinal, metaData.GetType().ToString(), metaData.TraceString()); } this._command.OnParameterAvailableSmi(metaData, parameterValues, ordinal); }
private static void SetString_FromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DbDataReader reader, int offset) { string value = reader.GetString(ordinal); int length = CheckXetParameters(metaData.SqlDbType, metaData.MaxLength, value.Length, 0, NoLengthLimit /* buffer */, offset, NoLengthLimit /* request */); setters.SetString(sink, ordinal, value, offset, length); sink.ProcessMessagesAndThrow(); }
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(); } } }
private static void SetDateTimeOffset_Unchecked(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, DateTimeOffset value) { setters.SetDateTimeOffset(sink, ordinal, value); sink.ProcessMessagesAndThrow(); }
// 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; }
// 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(); }
internal static object GetOutputParameterV200Smi(SmiEventSink_Default sink, SmiTypedGetterSetter getters, int ordinal, SmiMetaData metaData, SmiContext context, SqlBuffer targetBuffer) { object result = null; if (IsDBNull_Unchecked(sink, getters, ordinal)) { GetNullOutputParameterSmi(metaData, targetBuffer, ref result); return result; } switch (metaData.SqlDbType) { case SqlDbType.Date: targetBuffer.SetToDate(GetDateTime_Unchecked(sink, getters, ordinal)); return result; case SqlDbType.Time: targetBuffer.SetToTime(GetTimeSpan_Unchecked(sink, getters, ordinal), metaData.Scale); return result; case SqlDbType.DateTime2: targetBuffer.SetToDateTime2(GetDateTime_Unchecked(sink, getters, ordinal), metaData.Scale); return result; case SqlDbType.DateTimeOffset: targetBuffer.SetToDateTimeOffset(GetDateTimeOffset_Unchecked(sink, getters, ordinal), metaData.Scale); return result; case SqlDbType.Variant: metaData = getters.GetVariantType(sink, ordinal); sink.ProcessMessagesAndThrow(); GetOutputParameterV200Smi(sink, getters, ordinal, metaData, context, targetBuffer); return result; } return GetOutputParameterV3Smi(sink, getters, ordinal, metaData, context, targetBuffer); }
// 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); }
// UDTs and null variants come back via return value, all else is via targetBuffer. // implements SqlClient 1.1-compatible output parameter semantics internal static object GetOutputParameterV200Smi( SmiEventSink_Default sink, // event sink for errors SmiTypedGetterSetter getters, // getters interface to grab value from int ordinal, // parameter within getters SmiMetaData metaData, // Getter's type for this ordinal SmiContext context, // used to obtain scratch streams SqlBuffer targetBuffer // destination ) { object result = null; // Workaround for UDT hack in non-Smi code paths. if ( IsDBNull_Unchecked( sink, getters, ordinal ) ) { GetNullOutputParameterSmi(metaData, targetBuffer, ref result); } else { switch(metaData.SqlDbType) { // new types go here case SqlDbType.Variant: // Handle variants specifically for v200, since they could contain v200 types // For variants, recur using the current value's sqldbtype metaData = getters.GetVariantType( sink, ordinal ); sink.ProcessMessagesAndThrow(); Debug.Assert( SqlDbType.Variant != metaData.SqlDbType, "Variant-within-variant not supposed to be possible!" ); GetOutputParameterV200Smi( sink, getters, ordinal, metaData, context, targetBuffer ); break; case SqlDbType.Date: targetBuffer.SetToDate(GetDateTime_Unchecked(sink, getters, ordinal)); break; case SqlDbType.DateTime2: targetBuffer.SetToDateTime2(GetDateTime_Unchecked(sink, getters, ordinal), metaData.Scale); break; case SqlDbType.Time: targetBuffer.SetToTime(GetTimeSpan_Unchecked(sink, getters, ordinal), metaData.Scale); break; case SqlDbType.DateTimeOffset: targetBuffer.SetToDateTimeOffset(GetDateTimeOffset_Unchecked(sink, getters, ordinal), metaData.Scale); break; default: result = GetOutputParameterV3Smi(sink, getters, ordinal, metaData, context, targetBuffer); break; } } return result; }
internal override void ParameterAvailable(SmiParameterMetaData metaData, SmiTypedGetterSetter paramValue, int ordinal) { if (null == _parent) { throw SQL.UnexpectedSmiEvent(UnexpectedEventType.ParameterAvailable); } _parent.ParameterAvailable(metaData, paramValue, ordinal); }
internal virtual void ParameterAvailable(SmiParameterMetaData metaData, SmiTypedGetterSetter paramValue, int ordinal) { ADP.InternalError(ADP.InternalErrorCode.UnimplementedSMIMethod); }