// 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; }
private bool TryReadSqlDateTime(SqlBuffer value, byte tdsType, int length, byte scale, TdsParserStateObject stateObj) { byte[] datetimeBuffer = new byte[length]; if (!stateObj.TryReadByteArray(datetimeBuffer, 0, length)) { return false; } switch (tdsType) { case TdsEnums.SQLDATE: Debug.Assert(length == 3, "invalid length for date type!"); value.SetToDate(datetimeBuffer); break; case TdsEnums.SQLTIME: Debug.Assert(3 <= length && length <= 5, "invalid length for time type!"); value.SetToTime(datetimeBuffer, length, scale); break; case TdsEnums.SQLDATETIME2: Debug.Assert(6 <= length && length <= 8, "invalid length for datetime2 type!"); value.SetToDateTime2(datetimeBuffer, length, scale); break; case TdsEnums.SQLDATETIMEOFFSET: Debug.Assert(8 <= length && length <= 10, "invalid length for datetimeoffset type!"); value.SetToDateTimeOffset(datetimeBuffer, length, scale); break; default: Debug.Assert(false, "ReadSqlDateTime is called with the wrong tdsType"); break; } return true; }
/// <summary> /// Deserializes the unencrypted bytes into a value based on the target type info. /// </summary> internal bool DeserializeUnencryptedValue (SqlBuffer value, byte[] unencryptedBytes, SqlMetaDataPriv md, TdsParserStateObject stateObj, byte normalizationVersion) { if (normalizationVersion != 0x01) { throw SQL.UnsupportedNormalizationVersion(normalizationVersion); } byte tdsType = md.baseTI.tdsType; int length = unencryptedBytes.Length; // For normalized types, the length and scale of the actual type might be different than the value's. int denormalizedLength = md.baseTI.length; byte denormalizedScale = md.baseTI.scale; Debug.Assert (false == md.baseTI.isEncrypted, "Double encryption detected"); switch (tdsType) { // We normalize to allow conversion across data types. All data types below are serialized into a BIGINT. case TdsEnums.SQLBIT: case TdsEnums.SQLBITN: case TdsEnums.SQLINTN: case TdsEnums.SQLINT1: case TdsEnums.SQLINT2: case TdsEnums.SQLINT4: case TdsEnums.SQLINT8: Debug.Assert(length == 8, "invalid length for SqlInt64 type!"); byte byteValue; long longValue; if (unencryptedBytes.Length != 8) { return false; } longValue = BitConverter.ToInt64(unencryptedBytes, 0); if (tdsType == TdsEnums.SQLBIT || tdsType == TdsEnums.SQLBITN) { value.Boolean = (longValue != 0); break; } if (tdsType == TdsEnums.SQLINT1 || denormalizedLength == 1) value.Byte = (byte)longValue; else if (tdsType == TdsEnums.SQLINT2 || denormalizedLength == 2) value.Int16 = (Int16)longValue; else if (tdsType == TdsEnums.SQLINT4 || denormalizedLength == 4) value.Int32 = (Int32)longValue; else value.Int64 = longValue; break; case TdsEnums.SQLFLTN: if (length == 4) { goto case TdsEnums.SQLFLT4; } else { goto case TdsEnums.SQLFLT8; } case TdsEnums.SQLFLT4: Debug.Assert(length == 4, "invalid length for SqlSingle type!"); float singleValue; if (unencryptedBytes.Length != 4) { return false; } singleValue = BitConverter.ToSingle(unencryptedBytes, 0); value.Single = singleValue; break; case TdsEnums.SQLFLT8: double doubleValue; if (unencryptedBytes.Length != 8) { return false; } doubleValue = BitConverter.ToDouble(unencryptedBytes, 0); value.Double = doubleValue; break; // We normalize to allow conversion across data types. SMALLMONEY is serialized into a MONEY. case TdsEnums.SQLMONEYN: case TdsEnums.SQLMONEY4: case TdsEnums.SQLMONEY: { int mid; uint lo; if (unencryptedBytes.Length != 8) { return false; } mid = BitConverter.ToInt32(unencryptedBytes, 0); lo = BitConverter.ToUInt32(unencryptedBytes, 4); long l = (((long)mid) << 0x20) + ((long)lo); value.SetToMoney(l); break; } case TdsEnums.SQLDATETIMN: if (length == 4) { goto case TdsEnums.SQLDATETIM4; } else { goto case TdsEnums.SQLDATETIME; } case TdsEnums.SQLDATETIM4: ushort daypartShort, timepartShort; if (unencryptedBytes.Length != 4) { return false; } daypartShort = (UInt16)((unencryptedBytes[1] << 8) + unencryptedBytes[0]); timepartShort = (UInt16)((unencryptedBytes[3] << 8) + unencryptedBytes[2]); value.SetToDateTime(daypartShort, timepartShort * SqlDateTime.SQLTicksPerMinute); break; case TdsEnums.SQLDATETIME: int daypart; uint timepart; if (unencryptedBytes.Length != 8) { return false; } daypart = BitConverter.ToInt32(unencryptedBytes, 0); timepart = BitConverter.ToUInt32(unencryptedBytes, 4); value.SetToDateTime(daypart, (int)timepart); break; case TdsEnums.SQLUNIQUEID: { Debug.Assert(length == 16, "invalid length for SqlGuid type!"); value.SqlGuid = new SqlGuid(unencryptedBytes, true); // doesn't copy the byte array break; } case TdsEnums.SQLBINARY: case TdsEnums.SQLBIGBINARY: case TdsEnums.SQLBIGVARBINARY: case TdsEnums.SQLVARBINARY: case TdsEnums.SQLIMAGE: { // Note: Better not come here with plp data!! Debug.Assert(length <= TdsEnums.MAXSIZE, "Plp data decryption attempted"); // If this is a fixed length type, pad with zeros to get to the fixed length size. if (tdsType == TdsEnums.SQLBINARY || tdsType == TdsEnums.SQLBIGBINARY) { byte[] bytes = new byte[md.baseTI.length]; Buffer.BlockCopy(unencryptedBytes, 0, bytes, 0, unencryptedBytes.Length); unencryptedBytes = bytes; } value.SqlBinary = new SqlBinary(unencryptedBytes, true); // doesn't copy the byte array break; } case TdsEnums.SQLDECIMALN: case TdsEnums.SQLNUMERICN: // Check the sign from the first byte. int index = 0; byteValue = unencryptedBytes[index++]; bool fPositive = (1 == byteValue); // Now read the 4 next integers which contain the actual value. length = checked((int)length-1); int[] bits = new int[4]; int decLength = length>>2; for (int i = 0; i < decLength; i++) { // up to 16 bytes of data following the sign byte bits[i] = BitConverter.ToInt32(unencryptedBytes, index); index += 4; } value.SetToDecimal (md.baseTI.precision, md.baseTI.scale, fPositive, bits); break; case TdsEnums.SQLCHAR: case TdsEnums.SQLBIGCHAR: case TdsEnums.SQLVARCHAR: case TdsEnums.SQLBIGVARCHAR: case TdsEnums.SQLTEXT: { System.Text.Encoding encoding = md.baseTI.encoding; if (null == encoding) { encoding = _defaultEncoding; } if (null == encoding) { ThrowUnsupportedCollationEncountered(stateObj); } string strValue = encoding.GetString(unencryptedBytes, 0, length); // If this is a fixed length type, pad with spaces to get to the fixed length size. if (tdsType == TdsEnums.SQLCHAR || tdsType == TdsEnums.SQLBIGCHAR) { strValue = strValue.PadRight(md.baseTI.length); } value.SetToString(strValue); break; } case TdsEnums.SQLNCHAR: case TdsEnums.SQLNVARCHAR: case TdsEnums.SQLNTEXT: { string strValue = System.Text.Encoding.Unicode.GetString(unencryptedBytes, 0, length); // If this is a fixed length type, pad with spaces to get to the fixed length size. if (tdsType == TdsEnums.SQLNCHAR) { strValue = strValue.PadRight(md.baseTI.length / ADP.CharSize); } value.SetToString(strValue); break; } case TdsEnums.SQLDATE: Debug.Assert(length == 3, "invalid length for date type!"); value.SetToDate(unencryptedBytes); break; case TdsEnums.SQLTIME: // We normalize to maximum precision to allow conversion across different precisions. Debug.Assert(length == 5, "invalid length for time type!"); value.SetToTime(unencryptedBytes, length, TdsEnums.MAX_TIME_SCALE, denormalizedScale); break; case TdsEnums.SQLDATETIME2: // We normalize to maximum precision to allow conversion across different precisions. Debug.Assert(length == 8, "invalid length for datetime2 type!"); value.SetToDateTime2(unencryptedBytes, length, TdsEnums.MAX_TIME_SCALE, denormalizedScale); break; case TdsEnums.SQLDATETIMEOFFSET: // We normalize to maximum precision to allow conversion across different precisions. Debug.Assert(length == 10, "invalid length for datetimeoffset type!"); value.SetToDateTimeOffset(unencryptedBytes, length, TdsEnums.MAX_TIME_SCALE, denormalizedScale); break; default: MetaType metaType = md.baseTI.metaType; // If we don't have a metatype already, construct one to get the proper type name. if (metaType == null) { metaType = MetaType.GetSqlDataType(tdsType, userType:0, length:length); } throw SQL.UnsupportedDatatypeEncryption(metaType.TypeName); } return true; }
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); }
private void ReadSqlDateTime(SqlBuffer value, byte tdsType, int length, byte scale, TdsParserStateObject stateObj) { stateObj.ReadByteArray(this.datetimeBuffer, 0, length); switch (tdsType) { case 40: value.SetToDate(this.datetimeBuffer); return; case 0x29: value.SetToTime(this.datetimeBuffer, length, scale); return; case 0x2a: value.SetToDateTime2(this.datetimeBuffer, length, scale); return; case 0x2b: value.SetToDateTimeOffset(this.datetimeBuffer, length, scale); return; } }