Beispiel #1
0
        public static void CastToBinary(object value, SqlTypeCode typeCode, int size)
        {
            var type     = SqlTypeUtil.FromValue(value);
            var destType = PrimitiveTypes.Binary(typeCode, size);

            Assert.NotNull(type);
            Assert.IsType <SqlNumericType>(type);

            var number = (SqlNumber)SqlValueUtil.FromObject(value);

            Assert.True(type.CanCastTo(number, destType));
            var result = type.Cast(number, destType);

            Assert.IsAssignableFrom <ISqlBinary>(result);

            var binary = (ISqlBinary)result;

            var memStream = new MemoryStream();

            binary.GetInput().CopyTo(memStream);

            var bytes = memStream.ToArray();

            Assert.NotEmpty(bytes);

            var back = new SqlNumber(bytes);

            Assert.Equal(number, back);
        }
Beispiel #2
0
        public static void SerializeValue()
        {
            var type  = PrimitiveTypes.Binary(500);
            var value = new SqlBinary(new byte[] { 25, 87, 0, 156, 77 });

            var stream = new MemoryStream();

            type.Serialize(stream, value);

            stream.Seek(0, SeekOrigin.Begin);

            var value2 = type.Deserialize(stream);

            Assert.Equal(value, value2);
        }
Beispiel #3
0
        public static SqlType Deserialize(BinaryReader reader, ISqlTypeResolver typeResolver)
        {
            var typeCode = (SqlTypeCode)reader.ReadByte();

            if (SqlBooleanType.IsBooleanType(typeCode))
            {
                return(PrimitiveTypes.Boolean(typeCode));
            }
            if (SqlDateTimeType.IsDateType(typeCode))
            {
                return(PrimitiveTypes.DateTime(typeCode));
            }

            if (typeCode == SqlTypeCode.DayToSecond)
            {
                return(PrimitiveTypes.DayToSecond());
            }
            if (typeCode == SqlTypeCode.YearToMonth)
            {
                return(PrimitiveTypes.YearToMonth());
            }

            if (SqlCharacterType.IsStringType(typeCode))
            {
                var maxSize = reader.ReadInt32();

                CultureInfo locale    = null;
                var         hasLocale = reader.ReadByte() == 1;
                if (hasLocale)
                {
                    var name = reader.ReadString();
                    locale = new CultureInfo(name);
                }

                return(PrimitiveTypes.String(typeCode, maxSize, locale));
            }

            if (SqlNumericType.IsNumericType(typeCode))
            {
                var size  = reader.ReadInt32();
                var scale = reader.ReadInt32();

                return(PrimitiveTypes.Numeric(typeCode, size, scale));
            }

            if (SqlBinaryType.IsBinaryType(typeCode))
            {
                var size = reader.ReadInt32();
                return(PrimitiveTypes.Binary(typeCode, size));
            }

            if (typeCode == SqlTypeCode.Type)
            {
                if (typeResolver == null)
                {
                    throw new NotSupportedException("User-Defined types require a resolver context.");
                }

                // TODO: support type arguments
                var typeName = reader.ReadString();
                return(typeResolver.Resolve(new SqlTypeResolveInfo(typeName)));
            }

            /*
             * TODO:
             * if (typeCode == SqlTypeCode.QueryPlan)
             *      return new SqlQueryType();
             */

            if (typeCode == SqlTypeCode.Array)
            {
                var size = reader.ReadInt32();
                return(new SqlArrayType(size));
            }

            throw new NotSupportedException($"The type code '{typeCode}' does not support deserialization");
        }