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");
}
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();
}
public static SqlObject Boolean(SqlBoolean?value)
{
return(new SqlObject(PrimitiveTypes.Boolean(), value));
}
/// <summary>
/// Converts this object to a boolean type.
/// </summary>
/// <remarks>
/// This method is a shortcut to the original <see cref="CastTo"/>
/// method with a <see cref="BooleanType"/> parameter.
/// </remarks>
/// <returns>
/// Returns an instance of <see cref="Field"/> that is compatible
/// with a boolean type.
/// </returns>
/// <seealso cref="CastTo"/>
/// <seealso cref="PrimitiveTypes.Boolean()"/>
/// <seealso cref="BooleanType"/>
public Field AsBoolean()
{
return(CastTo(PrimitiveTypes.Boolean()));
}
public static Field Boolean(SqlBoolean value)
{
return(new Field(PrimitiveTypes.Boolean(), value));
}
private static void BinaryOp(Func <SqlType, Func <ISqlValue, ISqlValue, ISqlValue> > selector, bool value1, bool value2,
bool expected)
{
OperatorsUtil.Binary(PrimitiveTypes.Boolean(), selector, value1, value2, expected);
}
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();
}
public static void AddInvalidStyledQueryParameter(SqlQueryParameterNaming naming, string paramName)
{
var query = new SqlQuery($"INSERT INTO a (col1) VALUES ({paramName})", naming);
Assert.Throws <ArgumentException>(() => query.Parameters.Add(new SqlQueryParameter(paramName, PrimitiveTypes.Boolean(), SqlBoolean.True)));
}
public void Compare_BooleanToNumeric_Invalid() {
var type = PrimitiveTypes.Boolean();
Assert.NotNull(type);
Assert.Throws<ArgumentException>(() => type.Compare(SqlBoolean.True, (SqlNumber)22));
}
public static void GetInvalidBoolean()
{
Assert.Throws <ArgumentException>(() => PrimitiveTypes.Boolean(SqlTypeCode.Blob));
}
