public void TestWithDoubleBrackets()
{
String[] operators = new String[]
{
"OR",
"AND"
};
CriteriaExpression tree =
new CriteriaExpression("(Name = 'Test' OR Field1 >= 1) AND (Field2 <= 2 OR Name = 'Test2')", operators);
//Test left side
CriteriaExpression leftExpression = tree.Left;
Assert.AreEqual("(Name = 'Test' OR Field1 >= 1)", leftExpression.CompleteExpression);
Assert.AreEqual("Name = 'Test'", leftExpression.Left.CompleteExpression);
Assert.AreEqual("OR", leftExpression.Expression);
Assert.AreEqual("Field1 >= 1", leftExpression.Right.CompleteExpression);
//Tes operator
Assert.AreEqual("AND", tree.Expression);
//Test right side
CriteriaExpression rightExpression = tree.Right;
Assert.AreEqual("(Field2 <= 2 OR Name = 'Test2')", rightExpression.CompleteExpression);
Assert.AreEqual("Field2 <= 2", rightExpression.Left.CompleteExpression);
Assert.AreEqual("OR", rightExpression.Expression);
Assert.AreEqual("Name = 'Test2'", rightExpression.Right.CompleteExpression);
//Test complete
Assert.AreEqual("((Name = 'Test' OR Field1 >= 1) AND (Field2 <= 2 OR Name = 'Test2'))", tree.CompleteExpression);
}
/// <summary>
/// Private constructor to create a new expression using the
/// expression string provided
/// </summary>
/// <param name="expressionString">The expression string</param>
private Expression(string expressionString)
{
//TODO: Error check valid inputs
CriteriaExpression c = new CriteriaExpression(expressionString, _operators);
//Create left expression
if (c.IsLeaf())
{
}
if (c.Left.IsLeaf())
{
_leftExpression = new Parameter(c.Left.CompleteExpression);
}
else
{
_leftExpression = new Expression(c.Left.CompleteExpression);
}
//Create operator
_sqlOperator = new SqlOperator(c.Expression);
//Create right expression
if (c.Right.IsLeaf())
{
_rightExpression = new Parameter(c.Right.CompleteExpression);
}
else
{
_rightExpression = new Expression(c.Right.CompleteExpression);
}
}
public void Delete_Statement_With_From_Join_And_Where_Clauses()
{
// Exercise
DeleteStatement statement = ParserFactory.Execute <DeleteStatement>(
@"delete t from dbo.table as t join dbo.other o on o.id = a.id where field <> 2"
).First();
// Verify outcome
Assert.IsNotNull(statement);
Assert.AreEqual("t", statement.TableName);
Assert.AreEqual(1, statement.From.Count);
Assert.AreEqual("dbo.table", statement.From[0].Name);
Assert.AreEqual("t", statement.From[0].Alias.Name);
Assert.AreEqual(AliasType.As, statement.From[0].Alias.Type);
Assert.AreEqual(1, statement.From[0].Joins.Count);
Assert.AreEqual("dbo.other", statement.From[0].Joins[0].Name);
Assert.AreEqual("o", statement.From[0].Joins[0].Alias.Name);
Assert.AreEqual(AliasType.Implicit, statement.From[0].Joins[0].Alias.Type);
Assert.IsTrue(statement.Where is CriteriaExpression);
CriteriaExpression criteriaExpression = ( CriteriaExpression )statement.Where;
Assert.AreEqual("field <> 2", statement.Where.Value);
Assert.AreEqual("field", criteriaExpression.Left.Value);
Assert.AreEqual("<>", criteriaExpression.Operator);
Assert.AreEqual("2", criteriaExpression.Right.Value);
}
public void Can_Read_Negated_Expression()
{
var tokenizer = NewTokenizer("NOT ( A.Field = 1 OR A.Other IS NULL )");
tokenizer.ReadNextToken();
ExpressionParser parser = new ExpressionParser(tokenizer);
// exercise
Expression expression = parser.Execute();
// verify
Assert.IsNotNull(expression);
Assert.IsTrue(expression is NegationExpression);
NegationExpression negationExpression = (NegationExpression)expression;
Expression criteria = negationExpression.Expression;
Assert.IsTrue(criteria is NestedExpression);
NestedExpression nestedExpression = (NestedExpression)criteria;
Assert.IsTrue(nestedExpression.Expression is CriteriaExpression);
CriteriaExpression criteriaExpression = (CriteriaExpression)nestedExpression.Expression;
Assert.AreEqual("A.Field = 1", criteriaExpression.Left.Value);
Assert.AreEqual("OR", criteriaExpression.Operator);
Assert.AreEqual("A.Other IS NULL", criteriaExpression.Right.Value);
}
public void Select_With_Multi_Part_Where_Condition_With_Nested_Conditions()
{
// Exercise
SelectStatement statement = ParserFactory.Execute <SelectStatement>(@"
select fielda
from table1 t1
where ( t1.fieldd = 0 or t1.fieldc < 10 )
"
).First();
// Verify outcome
Assert.IsNotNull(statement);
Assert.IsTrue(statement.Where is NestedExpression);
NestedExpression nestedExpression = (NestedExpression)statement.Where;
CriteriaExpression criteriaExpression = (CriteriaExpression)nestedExpression.Expression;
Assert.AreEqual("or", criteriaExpression.Operator.ToLower());
Assert.IsTrue(criteriaExpression.Left is CriteriaExpression);
CriteriaExpression leftCriteriaExpression = (CriteriaExpression)criteriaExpression.Left;
Assert.AreEqual("t1.fieldd", leftCriteriaExpression.Left.Value);
Assert.AreEqual("=", leftCriteriaExpression.Operator);
Assert.AreEqual("0", leftCriteriaExpression.Right.Value);
CriteriaExpression rightCriteriaExpression = (CriteriaExpression)criteriaExpression.Right;
Assert.AreEqual("t1.fieldc", rightCriteriaExpression.Left.Value);
Assert.AreEqual("<", rightCriteriaExpression.Operator);
Assert.AreEqual("10", rightCriteriaExpression.Right.Value);
}
public void Update_Statement_With_From_And_Where_Clause()
{
// Exercise
UpdateStatement statement = ParserFactory.Execute <UpdateStatement>(
@"update t set field = 1 from dbo.table as t where field <> 2"
).First();
// Verify outcome
Assert.IsNotNull(statement);
Assert.AreEqual("t", statement.TableName);
Assert.AreEqual(1, statement.Fields.Count);
Assert.AreEqual("1", statement.Fields[0].Expression.Value);
Assert.AreEqual(1, statement.From.Count);
Assert.AreEqual("dbo.table", statement.From[0].Name);
Assert.AreEqual("t", statement.From[0].Alias.Name);
Assert.AreEqual(AliasType.As, statement.From[0].Alias.Type);
Assert.IsTrue(statement.Where is CriteriaExpression);
CriteriaExpression criteriaExpression = ( CriteriaExpression )statement.Where;
Assert.AreEqual("field <> 2", statement.Where.Value);
Assert.AreEqual("field", criteriaExpression.Left.Value);
Assert.AreEqual("<>", criteriaExpression.Operator);
Assert.AreEqual("2", criteriaExpression.Right.Value);
}
/// <inheritdoc />
public override IList <CriteriaExpression> GetExpressions()
{
var expressions = base.GetExpressions();
var expression = new CriteriaExpression();
if (this.CreatedBy != null)
{
expression.Equal("CreatedBy", this.CreatedBy);
}
if (this.EntityTypeName != null)
{
expression.Equal("EntityTypeName", this.EntityTypeName);
}
if (this.State != null)
{
expression.Equal("State", this.State);
}
if (this.RequestId != null)
{
expression.Equal("RequestId", this.RequestId);
}
expressions
.Add(expression);
return(expressions);
}
public void Select_With_Group_By_With_Having()
{
// Exercise
SelectStatement statement = ParserFactory.Execute <SelectStatement>(@"
select * from table group by field1, field2 having sum( field2 ) > 0
").First();
// Verify outcome
Assert.IsNotNull(statement);
Assert.AreEqual(1, statement.From.Count);
Assert.AreEqual("table", statement.From[0].Name);
Assert.AreEqual(2, statement.GroupBy.Count);
Assert.IsTrue(statement.Having is CriteriaExpression);
CriteriaExpression operatorExpression = (CriteriaExpression)statement.Having;
Assert.AreEqual(">", operatorExpression.Operator);
// verify that the left part of the criteria expression is a function expression
Assert.IsTrue(operatorExpression.Left is FunctionExpression);
FunctionExpression functionExpression = (FunctionExpression)operatorExpression.Left;
Assert.AreEqual("sum", functionExpression.Name);
Assert.AreEqual(1, functionExpression.Arguments.Count);
Assert.AreEqual("field2", functionExpression.Arguments[0].Value);
// the right branch is a simple IdentifierExpression
Assert.IsTrue(operatorExpression.Right is IdentifierExpression);
Assert.AreEqual("0", operatorExpression.Right.Value);
}
public void Select_With_Multi_Part_Where_Condition()
{
// Exercise
SelectStatement statement = ParserFactory.Execute <SelectStatement>(@"
select fielda
from table1 t1
where t1.fieldb = t1.fieldc
and t1.fieldd = 0
"
).First();
// Verify outcome
Assert.IsNotNull(statement);
Assert.IsTrue(statement.Where is CriteriaExpression);
CriteriaExpression criteriaExpression = (CriteriaExpression)statement.Where;
Assert.AreEqual("and", criteriaExpression.Operator.ToLower());
Assert.IsTrue(criteriaExpression.Left is CriteriaExpression);
CriteriaExpression leftCriteriaExpression = (CriteriaExpression)criteriaExpression.Left;
Assert.AreEqual("t1.fieldb", leftCriteriaExpression.Left.Value);
Assert.AreEqual("t1.fieldc", leftCriteriaExpression.Right.Value);
CriteriaExpression rightCriteriaExpression = (CriteriaExpression)criteriaExpression.Right;
Assert.AreEqual("t1.fieldd", rightCriteriaExpression.Left.Value);
Assert.AreEqual("0", rightCriteriaExpression.Right.Value);
}
public void TestWithQuotes()
{
String[] operators = new String[]
{
"OR",
"AND"
};
CriteriaExpression tree =
new CriteriaExpression("((Name = 'Te' '(st' and Field1 >= 1) or Field2 <= 2)", operators);
Assert.AreEqual("(Name = 'Te' '(st' AND Field1 >= 1)", tree.Left.CompleteExpression);
Assert.AreEqual("((Name = 'Te' '(st' AND Field1 >= 1) OR Field2 <= 2)", tree.CompleteExpression);
tree = new CriteriaExpression(" ((Name = 'Te' '(st' and Field1 >= 1) or Field2 <= 2) ", operators);
Assert.AreEqual("(Name = 'Te' '(st' AND Field1 >= 1)", tree.Left.CompleteExpression);
Assert.AreEqual("((Name = 'Te' '(st' AND Field1 >= 1) OR Field2 <= 2)", tree.CompleteExpression);
tree = new CriteriaExpression(" ((Name = 'Te' '(st' and Field1 >= 1) or Field2 <= 2)", operators);
Assert.AreEqual("(Name = 'Te' '(st' AND Field1 >= 1)", tree.Left.CompleteExpression);
Assert.AreEqual("((Name = 'Te' '(st' AND Field1 >= 1) OR Field2 <= 2)", tree.CompleteExpression);
tree = new CriteriaExpression(" ( (Name = 'Te' '(st' and Field1 >= 1) or Field2 <= 2)", operators);
Assert.AreEqual("(Name = 'Te' '(st' AND Field1 >= 1)", tree.Left.CompleteExpression);
Assert.AreEqual("((Name = 'Te' '(st' AND Field1 >= 1) OR Field2 <= 2)", tree.CompleteExpression);
Assert.AreEqual("Name = 'Te' '(st'", tree.Left.Left.CompleteExpression);
}
public void Nested_Criteria_Expression()
{
// setup
var tokenizer = NewTokenizer("A.Field1 = (2 + B.Field2)");
tokenizer.ReadNextToken();
ExpressionParser parser = new ExpressionParser(tokenizer);
// exercise
Expression expression = parser.Execute();
// verify
Assert.IsNotNull(expression);
Assert.IsTrue(expression is CriteriaExpression);
CriteriaExpression criteria = (CriteriaExpression)expression;
Assert.AreEqual("A.Field1", criteria.Left.Value);
Assert.AreEqual("=", criteria.Operator);
Assert.IsTrue(criteria.Right is NestedExpression);
NestedExpression nestedCriteria = (NestedExpression)criteria.Right;
Assert.IsTrue(nestedCriteria.Expression is OperatorExpression);
OperatorExpression operatorExpression = (OperatorExpression)nestedCriteria.Expression;
Assert.AreEqual("2", operatorExpression.Left.Value);
Assert.AreEqual("B.Field2", operatorExpression.Right.Value);
}
public void ExpressionsTypeIsBool()
{
var criteria = TermsCriteria.Build("field", memberInfo, "value");
var expression = new CriteriaExpression(criteria);
Assert.Equal(typeof(bool), expression.Type);
}
/// <summary>
/// 获取从业务对象
/// </summary>
/// <param name="criteriaExpression">条件表达式</param>
/// <param name="criteria">条件对象/JSON格式字符串/属性值队列</param>
/// <param name="pageNo">页码(1..N, 0为不分页)</param>
/// <param name="pageSize">分页大小</param>
/// <param name="orderBys">排序队列</param>
public new IList <TDetail> FetchDetails <TDetail>(CriteriaExpression criteriaExpression, object criteria, int pageNo, int pageSize = 10, params OrderBy <TDetail>[] orderBys)
where TDetail : BusinessBase <TDetail>
{
IList <TDetail> result = base.FetchDetails(criteriaExpression, criteria, pageNo, pageSize, orderBys);
SetDetail(result.ToArray());
return(result);
}
public void NodeTypeDoesNotConflictWithSystemNodeTypes()
{
var systemNodeTypes = Enum.GetValues(typeof(ExpressionType)).OfType <ExpressionType>();
var expression = new CriteriaExpression(criteria);
Assert.DoesNotContain(expression.NodeType, systemNodeTypes);
}
public void ToStringReturnsCriteriaToString()
{
var criteria = TermsCriteria.Build("field", memberInfo, "value");
var expression = new CriteriaExpression(criteria);
Assert.Equal(criteria.ToString(), expression.ToString());
}
public void CanReduceIsAlwaysFalse()
{
var criteria = TermsCriteria.Build("field", memberInfo, "value");
var expression = new CriteriaExpression(criteria);
Assert.False(expression.CanReduce);
}
public void ConstructorSetsCriteria()
{
var criteria = TermsCriteria.Build("field", memberInfo, "value");
var expression = new CriteriaExpression(criteria);
Assert.Same(criteria, expression.Criteria);
}
public void TestSimpleExpression_NotIn()
{
CriteriaExpression tree = new CriteriaExpression("Name not in ('Peter', 'Mark')");
Assert.AreEqual(" NOT IN ", tree.Expression);
Assert.AreEqual("Name", tree.Left.Expression);
Assert.AreEqual("('Peter', 'Mark')", tree.Right.Expression);
}
public void TestSimpleExpression_NotLike()
{
CriteriaExpression tree = new CriteriaExpression("Name not like 'Pet%'");
Assert.AreEqual(" NOT LIKE", tree.Expression);
Assert.AreEqual("Name", tree.Left.Expression);
Assert.AreEqual("Pet%", tree.Right.Expression);
}
public void TestSimpleExpressionWithOperatorInQuotes()
{
CriteriaExpression tree = new CriteriaExpression("Name = 'Peter = is not cool'");
Assert.AreEqual("=", tree.Expression);
Assert.AreEqual("Name", tree.Left.Expression);
Assert.AreEqual("Peter = is not cool", tree.Right.Expression);
}
/// <summary>
/// Constructor that creates a parameter based on the parameter clause
/// provided
/// </summary>
/// <param name="parameterClause">A clause for a single parameter.
/// This must have the syntax:<br/>
/// <code>parameterName sqlOperator parameterValue</code>
/// (e.g. <code>Field1 >= 3</code>)<br/>
/// NOTE_: The parameter value should not be enclosed in inverted
/// commas.</param>
public Parameter(string parameterClause)
{
CriteriaExpression c = new CriteriaExpression(parameterClause);
_parameterName = c.Left.Expression;
_fieldName = _parameterName;
_sqlOperator = c.Expression;
_parameterValue = c.Right.Expression;
}
private Expression VisitQueryString(Expression source, Expression queryExpression)
{
var constantQueryExpression = (ConstantExpression)queryExpression;
var criteriaExpression = new CriteriaExpression(new QueryStringCriteria(constantQueryExpression.Value.ToString()));
searchRequest.Query = ApplyCriteria(searchRequest.Query, criteriaExpression.Criteria);
return(Visit(source));
}
// public string SqlExpressionString(string tableNameFieldNameLeftSeperator,
// string tableNameFieldNameRightSeperator,
// string dateTimeLeftSeperator,
// string dateTimeRightSeperator)
// {
// return "(" + _leftExpression.SqlExpressionString(tableNameFieldNameLeftSeperator,
// tableNameFieldNameRightSeperator, dateTimeLeftSeperator, dateTimeRightSeperator) +
// " " + _sqlOperator.ExpressionString() +
// " " + _rightExpression.SqlExpressionString(tableNameFieldNameLeftSeperator,
// tableNameFieldNameRightSeperator, dateTimeLeftSeperator, dateTimeRightSeperator) + ")";
// }
#endregion //IExpression Interface Implementation
#region Static Members
/// <summary>
/// Creates a new IExpression object using the expression string provided.
/// </summary>
/// <param name="expressionClause">The expression string</param>
/// <returns>If the expression is a leaf object (it has no left and right
/// expressions), then a Parameter object is returned, otherwise an
/// Expression object is returned.</returns>
public static IExpression CreateExpression(string expressionClause)
{
CriteriaExpression c = new CriteriaExpression(expressionClause, _operators);
if (c.IsLeaf())
{
return(new Parameter(expressionClause));
}
return(new Expression(expressionClause));
}
public void TestSetLeftAndRight()
{
CriteriaExpression tree = new CriteriaExpression("Name = 'Peter' AND Age < 30");
tree.Left = new CriteriaExpression("Height > 20");
tree.Right = new CriteriaExpression("Town = 'Durban'");
Assert.AreEqual("(Height > 20)", tree.Left.CompleteExpression);
Assert.AreEqual("(Town = Durban)", tree.Right.CompleteExpression);
}
protected CriteriaExpression ProcessCriteriaExpression(Expression parent)
{
CriteriaExpression expression = new CriteriaExpression(parent);
expression.Left = ProcessExpression();
expression.Operator = GetOperator();
expression.Right = ProcessExpression();
return(expression);
}
protected bool IsExpressionOperatorAndOr(Expression expression)
{
CriteriaExpression where = expression as CriteriaExpression;
return(where == null ||
(
!String.Equals(where.Operator, Constants.And, StringComparison.InvariantCultureIgnoreCase)
&&
!String.Equals(where.Operator, Constants.Or, StringComparison.InvariantCultureIgnoreCase)
));
}
Expression VisitQueryString(Expression source, Expression queryExpression, Expression fieldsExpression = null)
{
var constantQueryExpression = (ConstantExpression)queryExpression;
var constantFieldExpression = fieldsExpression as ConstantExpression;
var constantFields = constantFieldExpression == null ? null : (string[])constantFieldExpression.Value;
var criteriaExpression = new CriteriaExpression(new QueryStringCriteria(constantQueryExpression.Value.ToString(), constantFields));
searchRequest.Query = AndCriteria.Combine(searchRequest.Query, criteriaExpression.Criteria);
return(Visit(source));
}
public void BuildWhenNotEqualTest()
{
var criteriaExpression = new CriteriaExpression();
criteriaExpression.NotEqual("Name", "value");
var builder = new CriteriaBuilder();
var expression = builder.Build <Customer>(criteriaExpression);
Assert.IsNotNull(expression);
Assert.AreEqual("((x.Name == null) OrElse (x.Name != \"value\"))", expression.Body.ToString());
}
public void TestSimpleExpression()
{
CriteriaExpression tree = new CriteriaExpression("Name = 'Peter'");
Assert.AreEqual("=", tree.Expression);
Assert.AreEqual("Name", tree.Left.Expression);
Assert.AreEqual("Peter", tree.Right.Expression);
tree = new CriteriaExpression("Amount >= 0");
Assert.AreEqual(">=", tree.Expression);
Assert.AreEqual("Amount", tree.Left.Expression);
Assert.AreEqual("0", tree.Right.Expression);
}
public void Select_With_Inner_Join_Condition()
{
// Exercise
SelectStatement statement = ParserFactory.Execute <SelectStatement>(@"
select fielda
from table1 t1
join table2 as t2
on t1.field1 = t2.field2
"
).First();
// Verify outcome
Assert.IsNotNull(statement);
// Test From
Assert.AreEqual(1, statement.From.Count);
Assert.AreEqual("table1", statement.From[0].Name);
Assert.AreEqual("t1", statement.From[0].Alias.Name);
Assert.AreEqual(AliasType.Implicit, statement.From[0].Alias.Type);
// Test Join
Assert.AreEqual(1, statement.From[0].Joins.Count);
Join join = statement.From[0].Joins[0];
Assert.AreEqual("table2", join.Name);
Assert.AreEqual("t2", join.Alias.Name);
Assert.AreEqual(AliasType.As, join.Alias.Type);
Assert.AreEqual(JoinType.Join, join.Type);
CriteriaExpression expr = join.Condition as CriteriaExpression;
Assert.AreEqual("=", expr.Operator);
Assert.IsTrue(expr.Left is IdentifierExpression);
var leftExpression = (IdentifierExpression)expr.Left;
Assert.AreEqual("t1", leftExpression.Parts[0]);
Assert.AreEqual("field1", leftExpression.Parts[1]);
Assert.AreEqual("t1.field1", expr.Left.Value);
var rightExpression = (IdentifierExpression)expr.Right;
Assert.AreEqual("t2", rightExpression.Parts[0]);
Assert.AreEqual("field2", rightExpression.Parts[1]);
Assert.AreEqual("t2.field2", expr.Right.Value);
Assert.AreEqual("t1.field1 = t2.field2", expr.Value);
}
