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 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 SingleValueKeyEqual(object value1, object value2, bool expected)
{
var key1 = new IndexKey(SqlObject.New(SqlValueUtil.FromObject(value1)));
var key2 = new IndexKey(SqlObject.New(SqlValueUtil.FromObject(value2)));
Assert.Equal(expected, key1.Equals(key2));
}
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 CompareSingleValue(object value1, object value2, int expetced)
{
var key1 = new IndexKey(SqlObject.New(SqlValueUtil.FromObject(value1)));
var key2 = new IndexKey(SqlObject.New(SqlValueUtil.FromObject(value2)));
Assert.Equal(expetced, key1.CompareTo(key2));
}
public static void ParseStringWithNamedParameter(string s, string funcName, string paramName, string paramType, object paramValue)
{
var exp = SqlExpression.Parse(s);
Assert.NotNull(exp);
Assert.Equal(SqlExpressionType.Function, exp.ExpressionType);
Assert.IsType <SqlFunctionExpression>(exp);
var function = (SqlFunctionExpression)exp;
Assert.Equal(ObjectName.Parse(funcName), function.FunctionName);
Assert.NotEmpty(function.Arguments);
Assert.Equal(1, function.Arguments.Length);
var param = function.Arguments[0];
Assert.NotNull(param);
Assert.True(param.IsNamed);
Assert.Equal(paramName, param.ParameterName);
Assert.IsType <SqlConstantExpression>(param.Value);
var type = SqlType.Parse(paramType);
var value = new SqlObject(type, SqlValueUtil.FromObject(paramValue));
Assert.Equal(value, ((SqlConstantExpression)param.Value).Value);
}
public static void ParseStringWithAnonParameter(string s, string funcName, string param1Type, object paramValue1, string param2Type, object paramValue2)
{
var exp = SqlExpression.Parse(s);
Assert.NotNull(exp);
Assert.Equal(SqlExpressionType.Function, exp.ExpressionType);
Assert.IsType <SqlFunctionExpression>(exp);
var function = (SqlFunctionExpression)exp;
Assert.Equal(ObjectName.Parse(funcName), function.FunctionName);
Assert.NotEmpty(function.Arguments);
Assert.Equal(2, function.Arguments.Length);
var param1 = function.Arguments[0];
var param2 = function.Arguments[1];
Assert.NotNull(param1);
Assert.NotNull(param2);
Assert.False(param1.IsNamed);
Assert.False(param2.IsNamed);
Assert.IsType <SqlConstantExpression>(param1.Value);
Assert.IsType <SqlConstantExpression>(param2.Value);
var pType1 = SqlType.Parse(param1Type);
var pType2 = SqlType.Parse(param2Type);
var value1 = new SqlObject(pType1, SqlValueUtil.FromObject(paramValue1));
var value2 = new SqlObject(pType2, SqlValueUtil.FromObject(paramValue2));
Assert.Equal(value1, ((SqlConstantExpression)param1.Value).Value);
Assert.Equal(value2, ((SqlConstantExpression)param2.Value).Value);
}
public static void CreateConstant(object value)
{
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var exp = SqlExpression.Constant(obj);
Assert.NotNull(exp.Value);
Assert.Equal(obj, exp.Value);
}
private static SqlBinaryExpression BinaryExpression(Func <SqlExpression, SqlExpression, SqlBinaryExpression> factory,
object value1, object value2)
{
var left = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value1)));
var right = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value2)));
return(factory(left, right));
}
public static void CreateUnary(SqlExpressionType expressionType, object value)
{
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var operand = SqlExpression.Constant(obj);
var exp = SqlExpression.Unary(expressionType, operand);
Assert.NotNull(exp.Operand);
Assert.IsType <SqlConstantExpression>(exp.Operand);
}
public async Task SimpleSelect(string column, SqlExpressionType op, object value, long expectedRowCount)
{
var columnName = new ObjectName(left.TableInfo.TableName, column);
var expression = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value)));
var result = await left.SimpleSelectAsync(null, columnName, op, expression);
Assert.NotNull(result);
Assert.Equal(expectedRowCount, result.RowCount);
}
public void CreateInvalidQuantify(SqlExpressionType expressionType, SqlExpressionType opType)
{
var left = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(212)));
var right = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(array)));
var binary = SqlExpression.Binary(opType, left, right);
Assert.Throws <ArgumentException>(() => SqlExpression.Quantify(expressionType, binary));
}
public static void GetCastType(object value, SqlTypeCode destTypeCode, int p, int s)
{
var targetType = PrimitiveTypes.Type(destTypeCode, new { precision = p, scale = s, maxSize = p, size = p });
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var exp = SqlExpression.Constant(obj);
var cast = SqlExpression.Cast(exp, targetType);
Assert.Equal(targetType, cast.TargetType);
}
public void GetVarAssingString(string name, object value, string expected)
{
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var exp = SqlExpression.Constant(obj);
var varRef = SqlExpression.VariableAssign(name, exp);
var sql = varRef.ToString();
Assert.Equal(expected, sql);
}
public static void SerializeStringMatch(SqlExpressionType expressionType, string value, string pattern)
{
var exp = SqlExpression.StringMatch(expressionType,
SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value))),
SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(pattern))), null);
var result = BinarySerializeUtil.Serialize(exp);
Assert.Equal(exp.ExpressionType, result.ExpressionType);
}
public static void GetUnaryType(SqlExpressionType expressionType, object value)
{
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var operand = SqlExpression.Constant(obj);
var exp = SqlExpression.Unary(expressionType, operand);
var sqlType = exp.Type;
Assert.Equal(obj.Type, sqlType);
}
public static void GetUnaryString(SqlExpressionType expressionType, object value, string expected)
{
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var operand = SqlExpression.Constant(obj);
var exp = SqlExpression.Unary(expressionType, operand);
var s = exp.ToString();
Assert.Equal(expected, s);
}
public static void SerializeUnary(SqlExpressionType expressionType, object value)
{
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var operand = SqlExpression.Constant(obj);
var exp = SqlExpression.Unary(expressionType, operand);
var result = BinarySerializeUtil.Serialize(exp);
Assert.Equal(exp.ExpressionType, result.ExpressionType);
}
private static SqlExpression FormDefaultValue(object value)
{
if (value == null)
{
return(null);
}
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
return(SqlExpression.Constant(obj));
}
public async Task NonCorrelatedSelect(string column, SqlExpressionType op, SqlExpressionType subOp, object value1, object value2, long expected)
{
var columnName = new ObjectName(left.TableInfo.TableName, column);
var exp1 = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value1)));
var exp2 = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value2)));
var array = SqlExpression.Constant(SqlObject.Array(new SqlArray(new[] { exp1, exp2 })));
var result = await left.SelectNonCorrelatedAsync(null, columnName, op, subOp, array);
Assert.NotNull(result);
Assert.Equal(expected, result.RowCount);
}
public static void GetReferenceAssignString(string name, object value, string expected)
{
var objName = ObjectName.Parse(name);
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var exp = SqlExpression.Constant(obj);
var refAssign = SqlExpression.ReferenceAssign(objName, exp);
var sql = refAssign.ToString();
Assert.Equal(expected, sql);
}
public static void CreateStringMatch(SqlExpressionType expressionType, string value, string pattern)
{
var exp = SqlExpression.StringMatch(expressionType,
SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value))),
SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(pattern))), null);
Assert.NotNull(exp);
Assert.Equal(expressionType, exp.ExpressionType);
Assert.NotNull(exp.Left);
Assert.NotNull(exp.Pattern);
}
public static void MultiValueKeyEqualToNull(object value1, object value2)
{
var key1 = new IndexKey(new[] {
SqlObject.New(SqlValueUtil.FromObject(value1)),
SqlObject.New(SqlValueUtil.FromObject(value2))
});
var key2 = key1.NullKey;
Assert.NotEqual(key1, key2);
Assert.True(key2.IsNull);
}
public static void GetStringMatchString(SqlExpressionType expressionType, string value, string pattern,
string expected)
{
var exp = SqlExpression.StringMatch(expressionType,
SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value))),
SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(pattern))), null);
var sql = exp.ToString();
Assert.Equal(expected, sql);
}
public static void GetBinaryString(SqlExpressionType expressionType, object value1, object value2, string expected)
{
var obj1 = SqlObject.New(SqlValueUtil.FromObject(value1));
var obj2 = SqlObject.New(SqlValueUtil.FromObject(value2));
var exp = SqlExpression.Binary(expressionType, SqlExpression.Constant(obj1), SqlExpression.Constant(obj2));
var s = exp.ToString();
Assert.Equal(expected, s);
}
public void CreateVarAssign(string name, object value)
{
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var exp = SqlExpression.Constant(obj);
var varRef = SqlExpression.VariableAssign(name, exp);
Assert.NotNull(varRef.Value);
Assert.Equal(exp, varRef.Value);
Assert.Equal(name, varRef.VariableName);
}
public static void SerializeBinary(SqlExpressionType type, object value1, object value2)
{
var binary = SqlExpression.Binary(type, SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value1))),
SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value2))));
var result = BinarySerializeUtil.Serialize(binary);
Assert.Equal(binary.ExpressionType, result.ExpressionType);
Assert.Equal(binary.Left.ExpressionType, result.Left.ExpressionType);
Assert.Equal(binary.Right.ExpressionType, result.Right.ExpressionType);
}
public static void CreateBinary(SqlExpressionType expressionType, object value1, object value2)
{
var obj1 = SqlObject.New(SqlValueUtil.FromObject(value1));
var obj2 = SqlObject.New(SqlValueUtil.FromObject(value2));
var exp = SqlExpression.Binary(expressionType, SqlExpression.Constant(obj1), SqlExpression.Constant(obj2));
Assert.NotNull(exp);
Assert.NotNull(exp.Left);
Assert.NotNull(exp.Right);
}
public static void SerializeCast(object value, SqlTypeCode destTypeCode, int p, int s)
{
var targetType = PrimitiveTypes.Type(destTypeCode, new { precision = p, scale = s, maxSize = p, size = p });
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var exp = SqlExpression.Constant(obj);
var cast = SqlExpression.Cast(exp, targetType);
var result = BinarySerializeUtil.Serialize(cast);
Assert.IsType <SqlConstantExpression>(result.Value);
}
public void CreateQuantify(SqlExpressionType expressionType, SqlExpressionType opType)
{
var left = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(212)));
var right = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(array)));
var binary = SqlExpression.Binary(opType, left, right);
var exp = SqlExpression.Quantify(expressionType, binary);
Assert.Equal(expressionType, exp.ExpressionType);
Assert.Equal(opType, exp.Expression.ExpressionType);
}