public static void PrepareNamedParameters(string paramName1, object value1, string paramName2, object value2)
{
var input1 = SqlObject.New(SqlValueUtil.FromObject(value1));
var input2 = SqlObject.New(SqlValueUtil.FromObject(value2));
var query = new SqlCommand($"SELECT * FROM a WHERE a.col1 = {paramName1} AND a.col2 = {paramName2}", SqlParameterNaming.Named);
query.Parameters.Add(new SqlParameter(paramName1, input1));
query.Parameters.Add(new SqlParameter(paramName2, input2));
var preparer = query.ExpressionPreparer;
Assert.NotNull(preparer);
var param1 = SqlExpression.Variable(paramName1);
var param2 = SqlExpression.Variable(paramName2);
Assert.True(preparer.CanPrepare(param1));
Assert.True(preparer.CanPrepare(param2));
var exp1 = preparer.Prepare(param1);
var exp2 = preparer.Prepare(param2);
Assert.NotNull(exp1);
Assert.NotNull(exp2);
Assert.IsType <SqlConstantExpression>(exp1);
Assert.IsType <SqlConstantExpression>(exp2);
Assert.Equal(input1, ((SqlConstantExpression)exp1).Value);
Assert.Equal(input2, ((SqlConstantExpression)exp2).Value);
}
public static void SubtractNumber(string value1, object value2, string expected)
{
var a = SqlYearToMonth.Parse(value1);
var b = SqlValueUtil.FromObject(value2);
Binary(type => type.Subtract, a, b, expected);
}
public static void PrepareMarkerParameters(object value1, object value2)
{
var input1 = SqlObject.New(SqlValueUtil.FromObject(value1));
var input2 = SqlObject.New(SqlValueUtil.FromObject(value2));
var query = new SqlCommand("SELECT * FROM a WHERE a.col1 = ? AND a.col2 = ?", SqlParameterNaming.Marker);
query.Parameters.Add(new SqlParameter("?", input1));
query.Parameters.Add(new SqlParameter("?", input2));
var preparer = query.ExpressionPreparer;
Assert.NotNull(preparer);
var param1 = SqlExpression.Parameter();
var param2 = SqlExpression.Parameter();
Assert.True(preparer.CanPrepare(param1));
Assert.True(preparer.CanPrepare(param2));
var exp1 = preparer.Prepare(param1);
var exp2 = preparer.Prepare(param2);
Assert.NotNull(exp1);
Assert.NotNull(exp2);
Assert.IsType <SqlConstantExpression>(exp1);
Assert.IsType <SqlConstantExpression>(exp2);
Assert.Equal(input1, ((SqlConstantExpression)exp1).Value);
Assert.Equal(input2, ((SqlConstantExpression)exp2).Value);
}
private static SqlExpression NewExpression(object value)
{
var sqlValue = SqlValueUtil.FromObject(value);
var obj = SqlObject.New(sqlValue);
return(SqlExpression.Constant(obj));
}
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);
}
public static void Convert_GetTypeCode(object value, TypeCode expected)
{
var number = (SqlNumber)SqlValueUtil.FromObject(value);
var typeCode = Convert.GetTypeCode(number);
Assert.Equal(expected, typeCode);
}
public static void Compare(SqlTypeCode typeCode, object value1, object value2, int expected)
{
var type = PrimitiveTypes.Type(typeCode);
var obj1 = new SqlObject(type, SqlValueUtil.FromObject(value1));
var obj2 = new SqlObject(type, SqlValueUtil.FromObject(value2));
var result = obj1.CompareTo(obj2);
Assert.Equal(expected, result);
}
public static void Search(string source, string pattern, bool matches)
{
var s = SqlValueUtil.FromObject(source);
Assert.IsType <SqlString>(s);
var stringSearch = new SqlDefaultStringSearch();
Assert.Equal(matches, stringSearch.Matches((SqlString)s, pattern, PatternSearch.EscapeCharacter));
}
public static void Binary(Func <ISqlValue, ISqlValue, ISqlValue> op, object value1, object value2, object expected)
{
var x = SqlValueUtil.FromObject(value1);
var y = SqlValueUtil.FromObject(value2);
var exp = SqlValueUtil.FromObject(expected);
var result = op(x, y);
Assert.Equal(exp, result);
}
public static void Binary(SqlType type, Func <SqlType, Func <ISqlValue, ISqlValue, SqlBoolean> > selector, object value1, object value2, bool expected)
{
var x = SqlValueUtil.FromObject(value1);
var y = SqlValueUtil.FromObject(value2);
var op = selector(type);
var result = op(x, y);
Assert.Equal(expected, (bool)result);
}
public static void Unary(SqlType type, Func <SqlType, Func <ISqlValue, ISqlValue> > selector, object value,
object expected)
{
var x = SqlValueUtil.FromObject(value);
var exp = SqlValueUtil.FromObject(expected);
var op = selector(type);
var result = op(x);
Assert.Equal(exp, result);
}
public void Compare(bool value1, object value2, int expected)
{
var a = (SqlBoolean)value1;
var b = SqlValueUtil.FromObject(value2);
Assert.True((a as ISqlValue).IsComparableTo(b));
var result = a.CompareTo(b);
Assert.Equal(expected, result);
}
public static void Cast(SqlType srcType, object value, SqlType destType, object expected)
{
var x = SqlValueUtil.FromObject(value);
Assert.True(srcType.CanCastTo(x, destType));
var exp = SqlValueUtil.FromObject(expected);
var result = srcType.Cast(x, destType);
Assert.Equal(exp, result);
}
private static void BinaryOp(Func <SqlNull, ISqlValue, bool> op, object other, bool expected)
{
var null1 = SqlNull.Value;
var value1 = SqlValueUtil.FromObject(other);
var result = op(null1, value1);
var b = (SqlBoolean)result;
var expectedNumber = (SqlBoolean)expected;
Assert.Equal(expectedNumber, b);
}
public static void Serialize(SqlTypeCode typeCode, int precision, int scale, object value)
{
var type = PrimitiveTypes.Type(typeCode, new { precision, size = precision, maxSize = precision, scale });
var sqlValue = SqlValueUtil.FromObject(value);
var obj = new SqlObject(type, sqlValue);
var result = BinarySerializeUtil.Serialize(obj);
Assert.Equal(obj, result);
Assert.Equal(type, result.Type);
Assert.Equal(sqlValue, result.Value);
}
public static void CastTo(SqlTypeCode srcTypeCode, bool value, SqlTypeCode destTypeCode, int p, int s, object expected) {
var b = (SqlBoolean) value;
var srcType = PrimitiveTypes.Boolean(srcTypeCode);
var destType = PrimitiveTypes.Type(destTypeCode, new {precision = p, scale = s, maxSize = p});
Assert.True(srcType.CanCastTo(b, destType));
var result = srcType.Cast(b, destType);
var expectedValue = SqlValueUtil.FromObject(expected);
Assert.Equal(expectedValue, result);
}
public static void CastToString(string value, SqlTypeCode destTypeCode, int size, string expexted)
{
var dts = SqlDayToSecond.Parse(value);
var type = new SqlDayToSecondType();
var destType = PrimitiveTypes.Type(destTypeCode, new { size });
var result = type.Cast(dts, destType);
var exp = SqlValueUtil.FromObject(expexted);
Assert.NotNull(result);
Assert.Equal(exp, result);
}
public static void EnumerateItems(params object[] values)
{
var array = new SqlArray(values.Select(NewExpression).ToArray());
Assert.Equal(values.Length, array.Length);
Assert.True(array.Length > 0);
var expected = SqlObject.New(SqlValueUtil.FromObject(values[0]));
var first = array.First();
Assert.IsType <SqlConstantExpression>(first);
var itemValue = ((SqlConstantExpression)first).Value;
Assert.Equal(expected, itemValue);
}
public static void Create(params object[] values)
{
var array = new SqlArray(values.Select(NewExpression).ToArray());
Assert.Equal(values.Length, array.Length);
Assert.True(array.Length > 0);
var expected = SqlObject.New(SqlValueUtil.FromObject(values[0]));
var item = array[0];
Assert.IsType <SqlConstantExpression>(item);
var itemValue = ((SqlConstantExpression)item).Value;
Assert.Equal(expected, itemValue);
}
private static SqlObject FromObject(object value)
{
if (value == null)
{
return(SqlObject.Null);
}
if (value is SqlTypeCode &&
(SqlTypeCode)value == SqlTypeCode.Unknown)
{
return(SqlObject.Unknown);
}
var sqlValue = SqlValueUtil.FromObject(value);
var sqlType = SqlTypeUtil.FromValue(value);
return(new SqlObject(sqlType, sqlValue));
}
public static void CompareTo(object other, int expected)
{
var value = SqlValueUtil.FromObject(other);
Assert.Equal(expected, (SqlNull.Value as IComparable <ISqlValue>).CompareTo(value));
}
public static void IsComparableTo(object other, bool expected)
{
var value = SqlValueUtil.FromObject(other);
Assert.Equal(expected, (SqlNull.Value as ISqlValue).IsComparableTo(value));
}
