|
public static Constant ( Field value ) : |
||
| value | Field | |
| return | ||
public static void GetConditionString(bool test, object ifTrue, object ifFalse, string expected)
{
var testExp = SqlExpression.Constant(SqlObject.Boolean(test));
var ifTrueExp = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(ifTrue)));
var ifFalseExp = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(ifFalse)));
var condition = SqlExpression.Condition(testExp, ifTrueExp, ifFalseExp);
var sql = condition.ToString();
Assert.Equal(expected, sql);
}
public void SimpleAssign()
{
var assign = SqlExpression.Assign(SqlExpression.VariableReference("t"), SqlExpression.Constant("test"));
var result = assign.EvaluateToConstant(null, variableResolver);
Assert.IsFalse(Field.IsNullField(result));
Assert.IsInstanceOf <StringType>(result.Type);
var value = ((SqlString)result.Value).ToString();
Assert.AreEqual("test", value);
}
public static void SerializeReferenceAssign(string name, object value)
{
var objName = ObjectName.Parse(name);
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var exp = SqlExpression.Constant(obj);
var refAssign = SqlExpression.ReferenceAssign(objName, exp);
var result = BinarySerializeUtil.Serialize(refAssign);
Assert.Equal(objName, result.ReferenceName);
Assert.IsType <SqlConstantExpression>(result.Value);
}
public static void FormatWithAnonArguments()
{
var expression = SqlExpression.FunctionCall(ObjectName.Parse("SYS.func1"), new SqlExpression[] {
SqlExpression.Constant("order1"),
SqlExpression.Constant(2)
});
var sql = expression.ToString();
var expected = "SYS.func1('order1', 2)";
Assert.AreEqual(expected, sql);
}
public static void GetStringMatchStringWithEscape(SqlExpressionType expressionType, string value, string pattern,
string escape, string expected)
{
var exp = SqlExpression.StringMatch(expressionType,
SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value))),
SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(pattern))),
SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(escape))));
var sql = exp.ToString();
Assert.Equal(expected, sql);
}
public static void GetGroupString()
{
var exp = SqlExpression.Binary(SqlExpressionType.Equal,
SqlExpression.Constant(SqlObject.Integer(33)),
SqlExpression.Constant(SqlObject.Integer(54)));
var group = SqlExpression.Group(exp);
const string expected = "(33 = 54)";
var sql = group.ToString();
Assert.Equal(expected, sql);
}
public static void SerializeGroup()
{
var exp = SqlExpression.Binary(SqlExpressionType.Equal,
SqlExpression.Constant(SqlObject.Integer(33)),
SqlExpression.Constant(SqlObject.Integer(54)));
var group = SqlExpression.Group(exp);
var result = BinarySerializeUtil.Serialize(group);
Assert.NotNull(result);
Assert.IsType <SqlBinaryExpression>(result.Expression);
}
public static void GetBinarySqlType(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));
var sqltType = exp.Type;
var wider = obj1.Type.Wider(obj2.Type);
Assert.Equal(wider, sqltType);
}
public void GetQuantifyString(SqlExpressionType expressionType, SqlExpressionType opType, string expected)
{
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);
var sql = exp.ToString();
Assert.Equal(expected, sql);
}
public override SqlExpression VisitUnary(SqlUnaryExpression unary)
{
var operand = Visit(unary.Operand);
if (operand.ExpressionType != SqlExpressionType.Constant)
{
throw new ExpressionEvaluateException("Operand of a unary operator could not be evaluated to a constant.");
}
var result = EvaluateUnary(((SqlConstantExpression)operand).Value, unary.ExpressionType);
return(SqlExpression.Constant(result));
}
public static async void ReduceConstant(object value)
{
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var exp = SqlExpression.Constant(obj);
Assert.False(exp.CanReduce);
Assert.NotNull(exp.Value);
var reduced = await exp.ReduceAsync(null);
Assert.IsType <SqlConstantExpression>(reduced);
Assert.Equal(obj, ((SqlConstantExpression)reduced).Value);
}
public static void CreateReferenceAssign(string name, object value)
{
var objName = ObjectName.Parse(name);
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var exp = SqlExpression.Constant(obj);
var refAssign = SqlExpression.ReferenceAssign(objName, exp);
Assert.NotNull(refAssign.ReferenceName);
Assert.NotNull(refAssign.Value);
Assert.Equal(objName, refAssign.ReferenceName);
}
public static async Task ReduceGroup()
{
var exp = SqlExpression.Binary(SqlExpressionType.Equal,
SqlExpression.Constant(SqlObject.Boolean(true)),
SqlExpression.Constant(SqlObject.Boolean(false)));
var group = SqlExpression.Group(exp);
var reduced = await group.ReduceAsync(null);
Assert.NotNull(reduced);
Assert.IsType <SqlConstantExpression>(reduced);
Assert.IsType <SqlObject>(((SqlConstantExpression)reduced).Value);
}
public void NumericAddToString()
{
var exp1 = SqlExpression.Constant(Field.Number(new SqlNumber(4566, 10)));
var exp2 = SqlExpression.Constant(Field.Number(new SqlNumber(8991.67, 10)));
var addExp = SqlExpression.Add(exp1, exp2);
string s = null;
Assert.DoesNotThrow(() => s = addExp.ToString());
Assert.IsNotNull(s);
Assert.IsNotEmpty(s);
Assert.AreEqual("4566 + 8991.670000", s);
}
public static void SerializeCondition(bool test, object ifTrue, object ifFalse)
{
var testExp = SqlExpression.Constant(SqlObject.Boolean(test));
var ifTrueExp = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(ifTrue)));
var ifFalseExp = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(ifFalse)));
var condition = SqlExpression.Condition(testExp, ifTrueExp, ifFalseExp);
var result = BinarySerializeUtil.Serialize(condition);
Assert.NotNull(result.Test);
Assert.NotNull(result.IfTrue);
Assert.NotNull(result.IfFalse);
}
public override SqlExpression VisitCast(SqlCastExpression castExpression)
{
var valueExp = Visit(castExpression.Value);
if (valueExp.ExpressionType != SqlExpressionType.Constant)
{
throw new ExpressionEvaluateException(String.Format("Cannot CAST an expression of type {0}.", valueExp.ExpressionType));
}
var value = ((SqlConstantExpression)valueExp).Value;
var casted = value.CastTo(castExpression.SqlType);
return(SqlExpression.Constant(casted));
}
public async Task ReduceVarAssign(string name, object value)
{
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var exp = SqlExpression.Constant(obj);
var varRef = SqlExpression.VariableAssign(name, exp);
Assert.True(varRef.CanReduce);
var result = await varRef.ReduceAsync(context);
Assert.NotNull(result);
Assert.IsType <SqlConstantExpression>(result);
}
public SqlQuantifyExpressionTests()
{
var mock = new Mock <IContext>();
mock.SetupGet(x => x.Scope)
.Returns(new ServiceContainer());
context = mock.Object;
array = new SqlArray(new SqlExpression[] {
SqlExpression.Constant(SqlObject.New((SqlNumber)2203.112)),
SqlExpression.Constant(SqlObject.New((SqlNumber)32)),
SqlExpression.Constant(SqlObject.New((SqlNumber)0.9923))
});
}
public void SerializeQuantify(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);
var result = BinarySerializeUtil.Serialize(exp);
Assert.IsType <SqlBinaryExpression>(result.Expression);
Assert.Equal(expressionType, result.ExpressionType);
Assert.Equal(opType, result.Expression.ExpressionType);
}
public static void SimpleCase()
{
var first = SqlExpression.Constant(34);
var second = SqlExpression.Add(SqlExpression.Constant(10), SqlExpression.Constant(24));
var condition = SqlExpression.Equal(first, second);
var returnExpression = SqlExpression.Constant("It was equal");
var conditional = SqlExpression.Conditional(condition, returnExpression);
var result = conditional.EvaluateToConstant(null, null);
Assert.IsNotNull(result);
Assert.IsFalse(Field.IsNullField(result));
Assert.AreEqual("It was equal", result.Value.ToString());
}
public static async Task ReduceCondition(bool test, object ifTrue, object ifFalse, object expected)
{
var testExp = SqlExpression.Constant(SqlObject.Boolean(test));
var ifTrueExp = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(ifTrue)));
var ifFalseExp = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(ifFalse)));
var condition = SqlExpression.Condition(testExp, ifTrueExp, ifFalseExp);
var result = await condition.ReduceAsync(null);
Assert.IsType <SqlConstantExpression>(result);
var expectedValue = SqlObject.New(SqlValueUtil.FromObject(expected));
Assert.Equal(expectedValue, ((SqlConstantExpression)result).Value);
}
public override SqlExpression VisitAssign(SqlAssignExpression assign)
{
if (context.Request == null)
{
throw new ExpressionEvaluateException("Cannot assign a variable outside a query context.");
}
var valueExpression = Visit(assign.ValueExpression);
if (valueExpression.ExpressionType != SqlExpressionType.Constant)
{
throw new ExpressionEvaluateException("Cannot assign a variable from a non constant value.");
}
var reference = assign.ReferenceExpression;
var value = ((SqlConstantExpression)valueExpression).Value;
string variableName;
if (reference is SqlVariableReferenceExpression)
{
variableName = ((SqlVariableReferenceExpression)reference).VariableName;
}
else if (reference is SqlReferenceExpression)
{
var refName = ((SqlReferenceExpression)reference).ReferenceName;
if (refName.Parent != null) // This might be the assignment to a complex type attribute
{
throw new NotSupportedException(string.Format("Reference to '{0}' is not supported.", refName));
}
variableName = refName.Name;
}
else
{
throw new NotSupportedException();
}
try {
context.Request.SetVariable(variableName, valueExpression);
} catch (Exception ex) {
throw new ExpressionEvaluateException(String.Format("Could not assign value to variable '{0}'", reference), ex);
}
return(SqlExpression.Constant(value));
}
public void CastStringToDate()
{
var exp = SqlExpression.Cast(SqlExpression.Constant(DataObject.String("2015-09-01")), PrimitiveTypes.Date());
SqlExpression casted = null;
Assert.DoesNotThrow(() => casted = exp.Evaluate());
Assert.IsNotNull(casted);
Assert.IsInstanceOf <SqlConstantExpression>(casted);
var value = ((SqlConstantExpression)casted).Value;
Assert.IsNotNull(value.Value);
Assert.IsInstanceOf <DateType>(value.Type);
Assert.AreEqual(SqlTypeCode.Date, value.Type.TypeCode);
Assert.AreEqual(new SqlDateTime(2015, 09, 01), value.Value);
}
public void CastStringToNumber()
{
var exp = SqlExpression.Cast(SqlExpression.Constant(DataObject.String("12.3e4")), PrimitiveTypes.Numeric());
SqlExpression casted = null;
Assert.DoesNotThrow(() => casted = exp.Evaluate());
Assert.IsNotNull(casted);
Assert.IsInstanceOf <SqlConstantExpression>(casted);
var value = ((SqlConstantExpression)casted).Value;
Assert.IsNotNull(value.Value);
Assert.IsInstanceOf <NumericType>(value.Type);
Assert.AreEqual(SqlTypeCode.Numeric, value.Type.TypeCode);
Assert.AreEqual(SqlNumber.Parse("12.3e4"), value.Value);
}
public void CastBooleanTrueToString()
{
var exp = SqlExpression.Cast(SqlExpression.Constant(DataObject.Boolean(true)), PrimitiveTypes.String());
SqlExpression casted = null;
Assert.DoesNotThrow(() => casted = exp.Evaluate());
Assert.IsNotNull(casted);
Assert.IsInstanceOf <SqlConstantExpression>(casted);
var value = ((SqlConstantExpression)casted).Value;
Assert.IsNotNull(value.Value);
Assert.IsInstanceOf <StringType>(value.Type);
Assert.AreEqual(SqlTypeCode.String, value.Type.TypeCode);
Assert.AreEqual(new SqlString("True"), value.Value);
}
public void CastStringToBooleanFalse()
{
var exp = SqlExpression.Cast(SqlExpression.Constant(DataObject.String("false")), PrimitiveTypes.Boolean());
SqlExpression casted = null;
Assert.DoesNotThrow(() => casted = exp.Evaluate());
Assert.IsNotNull(casted);
Assert.IsInstanceOf <SqlConstantExpression>(casted);
var value = ((SqlConstantExpression)casted).Value;
Assert.IsNotNull(value.Value);
Assert.IsInstanceOf <BooleanType>(value.Type);
Assert.AreEqual(SqlTypeCode.Boolean, value.Type.TypeCode);
Assert.AreEqual(SqlBoolean.False, value.Value);
}
public override SqlExpression VisitQuery(SqlQueryExpression query)
{
if (context.Request == null)
{
throw new ExpressionEvaluateException("A query expression is required to evaluate a query.");
}
try {
var planner = context.Request.Context.QueryPlanner();
var plan = planner.PlanQuery(new QueryInfo(context.Request, query));
return(SqlExpression.Constant(new DataObject(new QueryType(), new SqlQueryObject(plan))));
} catch (ExpressionEvaluateException) {
throw;
} catch (Exception ex) {
throw new ExpressionEvaluateException("Evaluation of a QUERY expression could not generate a plan.", ex);
}
}
public static void CaseNestedFalse()
{
var first = SqlExpression.Constant(34);
var second = SqlExpression.Add(SqlExpression.Constant(10), SqlExpression.Constant(34));
var condition = SqlExpression.Equal(first, second);
var ifTrue = SqlExpression.Constant("It was equal");
var ifFalseReturn = SqlExpression.Constant("It was not equal");
var ifFalse = SqlExpression.Conditional(SqlExpression.Constant(true), ifFalseReturn);
var conditional = SqlExpression.Conditional(condition, ifTrue, ifFalse);
var result = conditional.EvaluateToConstant(null, null);
Assert.IsNotNull(result);
Assert.IsFalse(Field.IsNullField(result));
Assert.AreEqual("It was not equal", result.Value.ToString());
}
public void CastStringToInteger()
{
var exp = SqlExpression.Cast(SqlExpression.Constant(Field.String("1234")), PrimitiveTypes.Integer());
SqlExpression casted = null;
Assert.DoesNotThrow(() => casted = exp.Evaluate());
Assert.IsNotNull(casted);
Assert.IsInstanceOf <SqlConstantExpression>(casted);
var value = ((SqlConstantExpression)casted).Value;
Assert.IsNotNull(value.Value);
Assert.IsInstanceOf <NumericType>(value.Type);
Assert.AreEqual(SqlTypeCode.Integer, value.Type.TypeCode);
Assert.AreEqual(new SqlNumber(1234), value.Value);
}
public void CastDateToString()
{
var date = DataObject.Date(new SqlDateTime(2015, 02, 03));
var exp = SqlExpression.Cast(SqlExpression.Constant(date), PrimitiveTypes.String());
SqlExpression casted = null;
Assert.DoesNotThrow(() => casted = exp.Evaluate());
Assert.IsNotNull(casted);
Assert.IsInstanceOf <SqlConstantExpression>(casted);
var value = ((SqlConstantExpression)casted).Value;
Assert.IsNotNull(value.Value);
Assert.IsInstanceOf <StringType>(value.Type);
Assert.AreEqual(SqlTypeCode.String, value.Type.TypeCode);
Assert.AreEqual(new SqlString("2015-02-03"), value.Value);
}