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); }