Beispiel #1
0
        public static void SerializeIntegerValue(long?value)
        {
            ISqlValue number = value == null ? (ISqlValue)SqlNull.Value : (SqlNumber)value.Value;

            var type = PrimitiveTypes.BigInt();

            var stream = new MemoryStream();

            type.Serialize(stream, number);

            stream.Seek(0, SeekOrigin.Begin);

            var result = type.Deserialize(stream);

            Assert.Equal(number, result);
        }
Beispiel #2
0
        protected override ISession CreateAdminSession(IDatabase database)
        {
            using (var session = base.CreateAdminSession(database)) {
                using (var query = session.CreateQuery()) {
                    var tableInfo = new TableInfo(ObjectName.Parse("APP.people"));
                    tableInfo.AddColumn("id", PrimitiveTypes.BigInt());
                    tableInfo.AddColumn("first_name", PrimitiveTypes.String(), true);
                    tableInfo.AddColumn("last_name", PrimitiveTypes.String());
                    tableInfo.AddColumn("age", PrimitiveTypes.TinyInt());

                    query.CreateTable(tableInfo);
                    query.Commit();
                }
            }

            return(base.CreateAdminSession(database));
        }
 public static SqlObject BigInt(long value)
 {
     return(new SqlObject(PrimitiveTypes.BigInt(), (SqlNumber)value));
 }
        private static SqlType GetSqlType(ISqlValue value)
        {
            if (value == null ||
                SqlNull.Value == value)
            {
                throw new ArgumentException();
            }

            if (value is SqlNumber)
            {
                var number = (SqlNumber)value;

                if (number.CanBeInt32)
                {
                    return(PrimitiveTypes.Integer());
                }
                if (number.CanBeInt64)
                {
                    return(PrimitiveTypes.BigInt());
                }

                if (number.Precision == SqlNumericType.FloatPrecision)
                {
                    return(new SqlNumericType(SqlTypeCode.Float, number.Precision, number.Scale));
                }
                if (number.Precision == SqlNumericType.DoublePrecision)
                {
                    return(new SqlNumericType(SqlTypeCode.Double, number.Precision, number.Scale));
                }
                if (number.Precision == SqlNumericType.DecimalPrecision)
                {
                    return(new SqlNumericType(SqlTypeCode.Decimal, number.Precision, number.Scale));
                }

                return(PrimitiveTypes.Numeric(number.Precision, number.Scale));
            }

            if (value is ISqlString)
            {
                // TODO: support the long string
                var length = ((ISqlString)value).Length;

                return(PrimitiveTypes.VarChar((int)length));
            }

            if (value is SqlBinary)
            {
                var bin = (SqlBinary)value;

                return(PrimitiveTypes.VarBinary((int)bin.Length));
            }

            if (value is SqlDateTime)
            {
                return(PrimitiveTypes.TimeStamp());
            }

            if (value is SqlBoolean)
            {
                return(PrimitiveTypes.Boolean());
            }

            if (value is SqlYearToMonth)
            {
                return(PrimitiveTypes.YearToMonth());
            }
            if (value is SqlDayToSecond)
            {
                return(PrimitiveTypes.DayToSecond());
            }

            if (value is SqlArray)
            {
                return(PrimitiveTypes.Array(((SqlArray)value).Length));
            }

            throw new NotSupportedException();
        }
Beispiel #5
0
        public static SqlType FromValue(object value)
        {
            if (value is SqlNumber)
            {
                var number = (SqlNumber)value;
                if (number.Scale == 0)
                {
                    if (number.Precision <= 3)
                    {
                        return(PrimitiveTypes.TinyInt());
                    }
                    if (number.Precision <= 5)
                    {
                        return(PrimitiveTypes.SmallInt());
                    }
                    if (number.Precision <= 10)
                    {
                        return(PrimitiveTypes.Integer());
                    }
                    if (number.Precision <= 19)
                    {
                        return(PrimitiveTypes.BigInt());
                    }
                }
                else
                {
                    if (number.Precision <= 8)
                    {
                        return(PrimitiveTypes.Float());
                    }
                    if (number.Precision <= 12)
                    {
                        return(PrimitiveTypes.Double());
                    }

                    return(PrimitiveTypes.Numeric(number.Precision, number.Scale));
                }
            }

            if (value is SqlBoolean)
            {
                return(PrimitiveTypes.Boolean());
            }

            if (value is bool)
            {
                return(PrimitiveTypes.Boolean());
            }

            if (value is double)
            {
                return(PrimitiveTypes.Double());
            }
            if (value is float)
            {
                return(PrimitiveTypes.Float());
            }
            if (value is int)
            {
                return(PrimitiveTypes.Integer());
            }
            if (value is long)
            {
                return(PrimitiveTypes.BigInt());
            }
            if (value is byte)
            {
                return(PrimitiveTypes.TinyInt());
            }
            if (value is short)
            {
                return(PrimitiveTypes.SmallInt());
            }

            if (value is string)
            {
                return(PrimitiveTypes.String());
            }

            throw new NotSupportedException();
        }