public NumericType(SqlTypeCode typeCode, int precision, int scale)
     : base("NUMERIC", typeCode)
 {
     AssertIsNumeric(typeCode);
     Precision = precision;
     Scale = scale;
 }

        public void GetRuntimeType(SqlTypeCode code, Type expectedType)
        {
            var type = PrimitiveTypes.Interval(code);
            var objType = type.GetRuntimeType();

            Assert.AreEqual(expectedType, objType);
        }

 public NumericType(SqlTypeCode sqlType, int size, byte scale)
     : base("NUMERIC", sqlType)
 {
     AssertIsNumeric(sqlType);
     Size = size;
     Scale = scale;
 }

 public ColumnAttribute(string name, SqlTypeCode type, int size, int scale)
 {
     ColumnName = name;
     SqlType = type;
     Size = size;
     Scale = scale;
 }

        public static void GetRuntime(SqlTypeCode code, Type expectedType)
        {
            var type = PrimitiveTypes.Numeric(code);

            var runtimeType = type.GetRuntimeType();
            Assert.AreEqual(expectedType, runtimeType);
        }

        public void ParseString(string input, SqlTypeCode typeCode)
        {
            var sqlType = SqlType.Parse(input);

            Assert.IsNotNull(sqlType);
            Assert.IsInstanceOf<DateType>(sqlType);
            Assert.AreEqual(typeCode, sqlType.TypeCode);
        }

        public void ParseString(string input, SqlTypeCode expected)
        {
            var type = SqlType.Parse(input);

            Assert.IsNotNull(type);
            Assert.IsInstanceOf<IntervalType>(type);

            Assert.AreEqual(expected, type.TypeCode);
        }

        public StringType(SqlTypeCode typeCode, int maxSize, Encoding encoding, CultureInfo locale)
            : base("STRING", typeCode)
        {
            if (encoding == null)
                throw new ArgumentNullException("encoding");

            AssertIsString(typeCode);
            MaxSize = maxSize;
            Locale = locale;
            Encoding = encoding;
        }

        public void CastToString(SqlTypeCode typeCode, bool value, string expected)
        {
            var type = PrimitiveTypes.Boolean(typeCode);

            var boolean = new SqlBoolean(value);

            var casted = type.CastTo(boolean, PrimitiveTypes.String());

            Assert.IsInstanceOf<SqlString>(casted);
            Assert.AreEqual(expected, casted.ToString());
        }

        public static SqlType Resolve(SqlTypeCode typeCode, string typeName, DataTypeMeta[] metadata, ITypeResolver resolver)
        {
            if (PrimitiveTypes.IsPrimitive(typeCode))
                return PrimitiveTypes.Resolve(typeCode, typeName, metadata);

            if (resolver == null)
                throw new NotSupportedException(String.Format("Cannot resolve type '{0}' without context.", typeName));

            var resolveCcontext = new TypeResolveContext(typeCode, typeName, metadata);
            return resolver.ResolveType(resolveCcontext);
        }

        public static void ParseString(string input, SqlTypeCode expectedTypeCode, int expectedSize)
        {
            var sqlType = SqlType.Parse(input);

            Assert.IsNotNull(sqlType);
            Assert.IsInstanceOf<BinaryType>(sqlType);
            Assert.AreEqual(expectedTypeCode, sqlType.TypeCode);

            var binType = (BinaryType) sqlType;
            Assert.AreEqual(expectedSize, binType.MaxSize);
        }

        public TypeResolveContext(SqlTypeCode typeCode, string typeName, DataTypeMeta[] meta)
        {
            TypeCode = typeCode;
            TypeName = typeName;

            this.meta = new Dictionary<string, DataTypeMeta>(StringComparer.OrdinalIgnoreCase);

            if (meta != null) {
                foreach (var typeMeta in meta) {
                    this.meta[typeMeta.Name] = typeMeta;
                }
            }
        }

        public static void CreateFrom(SqlTypeCode code, int precision, int scale, object value)
        {
            var type = PrimitiveTypes.Numeric(code, precision, scale);

            var result = type.CreateFrom(value);
            Assert.IsNotNull(result);
            Assert.IsFalse(result.IsNull);
            Assert.IsInstanceOf<SqlNumber>(result);

            var number = (SqlNumber) result;
            Assert.AreEqual(scale, number.Scale);
            Assert.AreEqual(precision, number.Precision);
        }

 public static BooleanType Boolean(SqlTypeCode sqlType)
 {
     return new BooleanType(sqlType);
 }

 public static DateType DateTime(SqlTypeCode sqlType)
 {
     return new DateType(sqlType);
 }

 public static BinaryType Binary(SqlTypeCode sqlType, int maxSize)
 {
     return new BinaryType(sqlType, maxSize);
 }

 private static void AssertIsNumeric(SqlTypeCode typeCode)
 {
     if (!IsNumericType(typeCode))
         throw new ArgumentException(String.Format("The type '{0}' is not a valid NUMERIC type.", typeCode));
 }

 private static void AssertDateType(SqlTypeCode sqlType)
 {
     if (!IsDateType(sqlType))
         throw new ArgumentException(String.Format("The SQL type {0} is not a valid DATE", sqlType), "sqlType");
 }

 private static int GetIntSize(SqlTypeCode sqlType)
 {
     switch (sqlType) {
         case SqlTypeCode.TinyInt:
             return 1;
         case SqlTypeCode.SmallInt:
             return 2;
         case SqlTypeCode.Integer:
             return 4;
         case SqlTypeCode.BigInt:
             return 8;
         default:
             return 0;
     }
 }

 internal static bool IsNumericType(SqlTypeCode typeCode)
 {
     return typeCode == SqlTypeCode.TinyInt ||
            typeCode == SqlTypeCode.SmallInt ||
            typeCode == SqlTypeCode.Integer ||
            typeCode == SqlTypeCode.BigInt ||
            typeCode == SqlTypeCode.Real ||
            typeCode == SqlTypeCode.Float ||
            typeCode == SqlTypeCode.Double ||
            typeCode == SqlTypeCode.Decimal ||
            typeCode == SqlTypeCode.Numeric;
 }