public static void Serialize(SqlTypeCode typeCode)
{
var type = new SqlDateTimeType(typeCode);
var result = BinarySerializeUtil.Serialize(type);
Assert.Equal(type, result);
}
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);
}
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 void AssertIsString(SqlTypeCode sqlType)
{
if (!IsStringType(sqlType))
{
throw new ArgumentException(String.Format("The type {0} is not a valid STRING type.", sqlType), "sqlType");
}
}
private static void AssertIsNumeric(SqlTypeCode typeCode)
{
if (!IsNumericType(typeCode))
{
throw new ArgumentException($"The type '{typeCode}' is not a valid NUMERIC type.");
}
}
public ColumnAttribute(string name, SqlTypeCode type, int size, int scale)
{
ColumnName = name;
SqlType = type;
Size = size;
Scale = scale;
}
public ColumnAttribute(string name, SqlTypeCode type, int size, int scale)
{
ColumnName = name;
SqlType = type;
Size = size;
Scale = scale;
}
private static int DiscoverPrecision(SqlTypeCode typeCode)
{
switch (typeCode)
{
case SqlTypeCode.TinyInt:
return(TinyIntPrecision);
case SqlTypeCode.SmallInt:
return(SmallIntPrecision);
case SqlTypeCode.Integer:
return(IntegerPrecision);
case SqlTypeCode.BigInt:
return(BigIntPrecision);
case SqlTypeCode.Float:
case SqlTypeCode.Real:
return(FloatPrecision);
case SqlTypeCode.Double:
return(DoublePrecision);
case SqlTypeCode.Decimal:
return(DecimalPrecision);
case SqlTypeCode.VarNumeric:
return(-1);
default:
throw new ArgumentException($"Type {typeCode} requires an explicit precision");
}
}
public void GetRuntimeType(SqlTypeCode code, Type expectedType)
{
var type = PrimitiveTypes.Interval(code);
var objType = type.GetRuntimeType();
Assert.AreEqual(expectedType, objType);
}
public void GetRuntimeType(SqlTypeCode code, Type expectedType)
{
var type = PrimitiveTypes.Interval(code);
var objType = type.GetRuntimeType();
Assert.AreEqual(expectedType, objType);
}
private static string GetTypeName(SqlTypeCode typeCode)
{
if (!IsPrimitive(typeCode))
{
throw new ArgumentException($"The type with code {typeCode} is not primitive");
}
switch (typeCode)
{
case SqlTypeCode.LongVarChar:
return("LONG VARCHAR");
case SqlTypeCode.LongVarBinary:
return("LONG VARBINARY");
case SqlTypeCode.YearToMonth:
return("YEAR TO MONTH");
case SqlTypeCode.DayToSecond:
return("DAY TO SECOND");
default:
return(typeCode.ToString().ToUpperInvariant());
}
}
public NumericType(SqlTypeCode typeCode, int precision, int scale)
: base("NUMERIC", typeCode)
{
AssertIsNumeric(typeCode);
Precision = precision;
Scale = scale;
}
public NumericType(SqlTypeCode typeCode, int precision, int scale)
: base("NUMERIC", typeCode)
{
AssertIsNumeric(typeCode);
Precision = precision;
Scale = scale;
}
public static void IsInstanceOf(SqlTypeCode typeCode, int?precision, byte?scale, object value, bool expected)
{
var type = new SqlNumericType(typeCode, precision ?? -1, scale ?? -1);
var number = SqlValueUtil.FromObject(value);
Assert.Equal(expected, type.IsInstanceOf(number));
}
public static void Serialize(SqlTypeCode typeCode, int precision, int scale)
{
var type = new SqlNumericType(typeCode, precision, scale);
var result = BinarySerializeUtil.Serialize(type);
Assert.Equal(type, result);
}
private static void AssertIsBoolean(SqlTypeCode sqlType)
{
if (!IsBooleanType(sqlType))
{
throw new ArgumentException(String.Format("The SQL type {0} is not BOOLEAN.", sqlType));
}
}
private static void AssertIsBoolean(SqlTypeCode sqlType)
{
if (!IsBooleanType(sqlType))
{
throw new ArgumentException($"The SQL type {sqlType} is not BOOLEAN.");
}
}
private static void AssertIsNumeric(SqlTypeCode typeCode)
{
if (!IsNumericType(typeCode))
{
throw new ArgumentException(String.Format("The type '{0}' is not a valid NUMERIC type.", typeCode));
}
}
public NumericType(SqlTypeCode sqlType, int size, byte scale)
: base("NUMERIC", sqlType)
{
AssertIsNumeric(sqlType);
Size = size;
Scale = scale;
}
public static void BinaryTypesEqual(SqlTypeCode typeCode1, int size1, SqlTypeCode typeCode2, int size2, bool expected)
{
var type1 = new SqlBinaryType(typeCode1, size1);
var type2 = new SqlBinaryType(typeCode2, size2);
Assert.Equal(expected, type1.Equals(type2));
}
public static void Serialize(SqlTypeCode typeCode, int size)
{
var type = new SqlBinaryType(typeCode, size);
var result = BinarySerializeUtil.Serialize(type);
Assert.Equal(type, result);
}
private static void AssertDateType(SqlTypeCode sqlType)
{
if (!IsDateType(sqlType))
{
throw new ArgumentException($"The SQL type {sqlType} is not a valid DATETIME", nameof(sqlType));
}
}
internal static bool IsDateType(SqlTypeCode sqlType)
{
return(sqlType == SqlTypeCode.Date ||
sqlType == SqlTypeCode.Time ||
sqlType == SqlTypeCode.TimeStamp ||
sqlType == SqlTypeCode.DateTime);
}
private static void AssertIsInterval(SqlTypeCode sqlType)
{
if (!IsIntervalType(sqlType))
{
throw new ArgumentException(String.Format("SQL Type {0} is not a valid INTERVAL.", sqlType.ToString().ToUpperInvariant()));
}
}
public static void Cast(object value, SqlTypeCode destTypeCode, int p, int s, object expected)
{
var srcType = SqlTypeUtil.FromValue(value);
var destType = PrimitiveTypes.Type(destTypeCode, new { precision = p, scale = s, maxSize = p, size = p });
Cast(srcType, value, destType, expected);
}
public void BooleanTypesEqual(SqlTypeCode typeCode1, SqlTypeCode typeCode2, bool expected)
{
var type1 = new SqlBooleanType(typeCode1);
var type2 = new SqlBooleanType(typeCode2);
Assert.Equal(expected, type1.Equals(type2));
}
public static void GetRuntime(SqlTypeCode code, Type expectedType)
{
var type = PrimitiveTypes.Numeric(code);
var runtimeType = type.GetRuntimeType();
Assert.AreEqual(expectedType, runtimeType);
}
public NumericType(SqlTypeCode typeCode, int size, byte scale)
: base("NUMERIC", typeCode)
{
AssertIsNumeric(typeCode);
Size = size;
Scale = scale;
}
private static void AssertIsBinary(SqlTypeCode sqlType)
{
if (!IsBinaryType(sqlType))
{
throw new ArgumentException(String.Format("The SQL type {0} is not a BINARY", sqlType));
}
}
private static bool IsBinaryType(SqlTypeCode sqlType)
{
return(sqlType == SqlTypeCode.Binary ||
sqlType == SqlTypeCode.VarBinary ||
sqlType == SqlTypeCode.LongVarBinary ||
sqlType == SqlTypeCode.Blob);
}
public static void ParseString(string s, SqlTypeCode typeCode) {
var type = SqlType.Parse(s);
Assert.NotNull(type);
Assert.Equal(typeCode, type.TypeCode);
Assert.IsType<SqlDateTimeType>(type);
}
public void GetString(SqlTypeCode typeCode, string expected)
{
var type = new SqlBooleanType(typeCode);
var s = type.ToString();
Assert.Equal(expected, s);
}
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 static void Cast(SqlTypeCode srcTypeCode, int p1, int s1, object value, SqlTypeCode destTypeCode, int p2, int s2,
object expected)
{
var srcType = PrimitiveTypes.Type(srcTypeCode, new { precision = p1, scale = s1, maxSize = p1, size = p1 });
var destType = PrimitiveTypes.Type(destTypeCode, new { precision = p2, scale = s2, maxSize = p2, size = p2 });
Cast(srcType, value, destType, expected);
}
public static void GetValidDateTimeType(SqlTypeCode typeCode) {
var type = new SqlDateTimeType(typeCode);
Assert.Equal(typeCode, type.TypeCode);
Assert.True(type.IsIndexable);
Assert.True(type.IsPrimitive);
Assert.False(type.IsLargeObject);
Assert.False(type.IsReference);
}
public void Serialize(SqlTypeCode typeCode)
{
var type = new SqlBooleanType(typeCode);
var result = BinarySerializeUtil.Serialize(type);
Assert.Equal(type, result);
}
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 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 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 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 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 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 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;
}
}
}
internal static bool IsDateType(SqlTypeCode sqlType)
{
return sqlType == SqlTypeCode.Date ||
sqlType == SqlTypeCode.Time ||
sqlType == SqlTypeCode.TimeStamp ||
sqlType == SqlTypeCode.DateTime;
}
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 GetFloatSize(SqlTypeCode sqlType)
{
switch (sqlType) {
default:
return 0;
case SqlTypeCode.Real:
return 4;
case SqlTypeCode.Float:
case SqlTypeCode.Double:
return 8;
}
}
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;
}
private static void AssertIsNumeric(SqlTypeCode typeCode)
{
if (!IsNumericType(typeCode))
throw new ArgumentException(String.Format("The type '{0}' is not a valid NUMERIC type.", typeCode));
}
public NumericType(SqlTypeCode typeCode)
: this(typeCode, -1)
{
}
public static StringType String(SqlTypeCode sqlType, int maxSize, Encoding encoding, CultureInfo locale)
{
return new StringType(sqlType, maxSize, encoding, locale);
}
public static DateType DateTime(SqlTypeCode sqlType)
{
return new DateType(sqlType);
}
public static StringType String(SqlTypeCode sqlType, Encoding encoding)
{
return String(sqlType, StringType.DefaultMaxSize, encoding);
}
public static StringType String(SqlTypeCode sqlType, int maxSize, Encoding encoding)
{
return String(sqlType, maxSize, encoding, null);
}
public static BinaryType Binary(SqlTypeCode sqlType, int maxSize)
{
return new BinaryType(sqlType, maxSize);
}
public static BinaryType Binary(SqlTypeCode sqlType)
{
return Binary(sqlType, -1);
}
public DateType(SqlTypeCode typeCode)
: base("DATE", typeCode)
{
AssertDateType(typeCode);
}
public NumericType(SqlTypeCode typeCode, int size)
: this(typeCode, size, 0)
{
}
public static BooleanType Boolean(SqlTypeCode sqlType)
{
return new BooleanType(sqlType);
}
public static StringType String(SqlTypeCode sqlType, Encoding encoding, CultureInfo locale)
{
return String(sqlType, StringType.DefaultMaxSize, encoding, locale);
}
