public override void VisitBooleanBinaryExpression(BooleanBinaryExpression booleanBinaryExpression) { var left = VisitPop(booleanBinaryExpression.Left); var right = VisitPop(booleanBinaryExpression.Right); Bool b = new Bool(); switch (booleanBinaryExpression.Type) { case BooleanBinaryType.AND: b.Must = new List <BoolOperation>() { left, right }; break; case BooleanBinaryType.OR: b.Should = new List <BoolOperation>() { left, right }; break; } Push(b); }
/// <summary> /// WHERE句 にコンストラクタで指定された条件式を追加する。 /// </summary> /// <param name="node">WHERE句</param> public override void ExplicitVisit(Microsoft.SqlServer.TransactSql.ScriptDom.WhereClause node) { try { var booleanExpression = FindBooleanExpression.Compile().Invoke(node); if (booleanExpression != null && BooleanBinaryExpressionType.HasValue) { booleanExpression = new BooleanBinaryExpression() { BinaryExpressionType = BooleanBinaryExpressionType.Value, FirstExpression = booleanExpression, SecondExpression = BooleanExpression, }; var booleanBinaryExpression = (BooleanBinaryExpression)booleanExpression; } else { booleanExpression = BooleanExpression; } var member = (MemberExpression)FindBooleanExpression.Body; var param = Expression.Parameter(typeof(BooleanExpression), "value"); var set = Expression.Lambda <Action <Microsoft.SqlServer.TransactSql.ScriptDom.WhereClause, BooleanExpression> >( Expression.Assign(member, param), FindBooleanExpression.Parameters[0], param); set.Compile().Invoke(node, booleanExpression); } catch (Exception e) { throw new InvalidOperationException("指定された条件式は追加できません。", e); } base.ExplicitVisit(node); }
public override void ExplicitVisit(BooleanBinaryExpression node) { if (node.BinaryExpressionType == BooleanBinaryExpressionType.And && JoinCondition == null) { base.ExplicitVisit(node); } }
public override void VisitBooleanBinaryExpression(BooleanBinaryExpression booleanBinaryExpression) { var left = VisitPop(booleanBinaryExpression.Left); var right = VisitPop(booleanBinaryExpression.Right); var binaryFilter = new BinaryQueryFilter(); switch (booleanBinaryExpression.Type) { case BooleanBinaryType.AND: binaryFilter.And = new List <BaseQueryFilter>() { left, right }; break; case BooleanBinaryType.OR: binaryFilter.Or = new List <BaseQueryFilter>() { left, right }; break; } Push(binaryFilter); }
private static List<BooleanBinaryExpression> CreateExpressionTreeForMultiKeySearchConditon(List<BooleanComparisonExpression> booleanComparisons) { var expressions = new List<BooleanBinaryExpression>(); BooleanBinaryExpression last = null; var counter = 0; foreach (var isNull in booleanComparisons) { var boolExpression = new BooleanBinaryExpression { SecondExpression = isNull, BinaryExpressionType = BooleanBinaryExpressionType.And }; if (last != null) { if (booleanComparisons.Count - 1 == ++counter) { last.FirstExpression = booleanComparisons.Last(); } else { last.FirstExpression = boolExpression; } } last = boolExpression; expressions.Add(last); } return expressions; }
private static List <BooleanBinaryExpression> CreateExpressionTreeForUpdateSearch(List <BooleanIsNullExpression> isNulls) { var expressions = new List <BooleanBinaryExpression>(); BooleanBinaryExpression last = null; var counter = 0; foreach (var isNull in isNulls) { var boolExpression = new BooleanBinaryExpression { SecondExpression = isNull, BinaryExpressionType = BooleanBinaryExpressionType.Or }; if (last != null) { if (isNulls.Count - 1 == ++counter) { last.FirstExpression = isNulls.Last(); } else { last.FirstExpression = boolExpression; } } last = boolExpression; expressions.Add(last); } return(expressions); }
private static List <BooleanBinaryExpression> CreateExpressionTreeForMultiKeySearchConditon(List <BooleanComparisonExpression> booleanComparisons) { var expressions = new List <BooleanBinaryExpression>(); BooleanBinaryExpression last = null; var counter = 0; foreach (var isNull in booleanComparisons) { var boolExpression = new BooleanBinaryExpression { SecondExpression = isNull, BinaryExpressionType = BooleanBinaryExpressionType.And }; if (last != null) { if (booleanComparisons.Count - 1 == ++counter) { last.FirstExpression = booleanComparisons.Last(); } else { last.FirstExpression = boolExpression; } } last = boolExpression; expressions.Add(last); } return(expressions); }
private void BuildEqualsSameLiteral(BooleanExpression search, ScalarExpression firstParam, Literal literal) { var newExpression = new BooleanParenthesisExpression(); var expression = new BooleanBinaryExpression(); newExpression.Expression = expression; expression.BinaryExpressionType = BooleanBinaryExpressionType.Or; var isnull = new BooleanIsNullExpression(); isnull.Expression = firstParam; expression.FirstExpression = isnull; var second = new BooleanComparisonExpression(); second.FirstExpression = firstParam; second.SecondExpression = literal; expression.SecondExpression = second; var sql = ScriptDom.GenerateTSql(newExpression); _replacementsToMake.Add(new Replacements { Original = _script.Substring(search.StartOffset, search.FragmentLength), OriginalLength = search.FragmentLength, OriginalOffset = search.StartOffset, Replacement = sql, OriginalFragment = _currentFragment }); }
public override void VisitBooleanBinaryExpression(BooleanBinaryExpression booleanBinaryExpression) { if (booleanBinaryExpression.Type == BooleanBinaryType.AND) { //Only go deeper if we are in an AND base.VisitBooleanBinaryExpression(booleanBinaryExpression); } }
public void TestBooleanBinaryExpressionAccept() { Mock <KoraliumSqlVisitor> mock = new Mock <KoraliumSqlVisitor>(); BooleanBinaryExpression booleanBinaryExpression = new BooleanBinaryExpression(); booleanBinaryExpression.Accept(mock.Object); mock.Verify(x => x.VisitBooleanBinaryExpression(booleanBinaryExpression)); }
public void Visit(BooleanBinaryExpression booleanBinaryExpression) { if (_innerVisitor != null) { booleanBinaryExpression.Accept(_innerVisitor); } booleanBinaryExpression.Left.Accept(this); booleanBinaryExpression.Right.Accept(this); }
public override void ExplicitVisit(BooleanBinaryExpression node) { node.FirstExpression.Accept(this); if (node.BinaryExpressionType == BooleanBinaryExpressionType.And) { _buffer.Append(" and "); } else if (node.BinaryExpressionType == BooleanBinaryExpressionType.Or) { _buffer.Append(" or "); } node.SecondExpression.Accept(this); }
public QsiBinaryExpressionNode VisitBooleanBinaryExpression(BooleanBinaryExpression booleanBinaryExpression) { return(TreeHelper.Create <QsiBinaryExpressionNode>(n => { n.Left.SetValue(VisitBooleanExpression(booleanBinaryExpression.FirstExpression)); n.Right.SetValue(VisitBooleanExpression(booleanBinaryExpression.SecondExpression)); n.Operator = booleanBinaryExpression.BinaryExpressionType switch { BooleanBinaryExpressionType.And => SqlServerKnownOperator.And, BooleanBinaryExpressionType.Or => SqlServerKnownOperator.Or, _ => throw new InvalidOperationException() }; })); }
public override void ExplicitVisit(BooleanBinaryExpression node) { // BinaryExpressionType + First + Second cs.CodeBinaryOperatorExpression binary = new cs.CodeBinaryOperatorExpression(); binary.Operator = ConvertToBinaryOperatorType(node.BinaryExpressionType); binary.Left = TryBuildFromNode(node.FirstExpression, ref lastHasError, ref lastError); binary.Right = TryBuildFromNode(node.SecondExpression, ref lastHasError, ref lastError); if (lastHasError) { } else { this.lastExpression = binary; } }
/// <summary> /// Converts a FetchXML <filter> to a SQL condition /// </summary> /// <param name="metadata">The metadata cache to use for the conversion</param> /// <param name="filter">The FetchXML filter to convert</param> /// <param name="prefix">The alias or name of the table that the <paramref name="filter"/> applies to</param> /// <param name="aliasToLogicalName">The mapping of table alias to logical name</param> /// <returns>The SQL condition equivalent of the <paramref name="filter"/></returns> private static BooleanExpression GetFilter(IAttributeMetadataCache metadata, filter filter, string prefix, IDictionary <string, string> aliasToLogicalName) { BooleanExpression expression = null; var type = filter.type == filterType.and ? BooleanBinaryExpressionType.And : BooleanBinaryExpressionType.Or; // Convert each <condition> within the filter foreach (var condition in filter.Items.OfType <condition>()) { var newExpression = GetCondition(metadata, condition, prefix, aliasToLogicalName); if (expression == null) { expression = newExpression; } else { expression = new BooleanBinaryExpression { FirstExpression = expression, BinaryExpressionType = type, SecondExpression = newExpression } }; } // Recurse into sub-<filter>s foreach (var subFilter in filter.Items.OfType <filter>()) { var newExpression = GetFilter(metadata, subFilter, prefix, aliasToLogicalName); if (expression == null) { expression = newExpression; } else { expression = new BooleanBinaryExpression { FirstExpression = expression, BinaryExpressionType = type, SecondExpression = newExpression } }; } return(expression); }
public void TestVisitBooleanBinaryExpression() { Mock <BooleanExpression> leftMock = new Mock <BooleanExpression>(); Mock <BooleanExpression> rightMock = new Mock <BooleanExpression>(); BooleanBinaryExpression booleanBinaryExpression = new BooleanBinaryExpression() { Left = leftMock.Object, Right = rightMock.Object }; KoraliumSqlVisitor koraliumSqlVisitor = new KoraliumSqlVisitor(); koraliumSqlVisitor.Visit(booleanBinaryExpression); leftMock.Verify(x => x.Accept(koraliumSqlVisitor)); rightMock.Verify(x => x.Accept(koraliumSqlVisitor)); }
public void TestCloneBooleanBinaryExpression() { BooleanBinaryExpression booleanBinaryExpression = new BooleanBinaryExpression() { Type = BooleanBinaryType.AND, Left = new BooleanComparisonExpression() { Type = BooleanComparisonType.Equals, Left = new ColumnReference() { Identifiers = new List <string>() { "c1" } }, Right = new IntegerLiteral() { Value = 3 } }, Right = new BooleanComparisonExpression() { Type = BooleanComparisonType.GreaterThan, Left = new ColumnReference() { Identifiers = new List <string>() { "c2" } }, Right = new IntegerLiteral() { Value = 17 } } }; var clone = booleanBinaryExpression.Clone() as BooleanBinaryExpression; Assert.AreEqual(booleanBinaryExpression, clone); Assert.IsFalse(ReferenceEquals(booleanBinaryExpression, clone)); Assert.IsFalse(ReferenceEquals(booleanBinaryExpression.Left, clone.Left)); Assert.IsFalse(ReferenceEquals(booleanBinaryExpression.Right, clone.Right)); }
private IBooleanExpression BooleanExpression(IBooleanExpression left, int minPrecedence) { while (IsBooleanOp()) { var token = Current; var type = BooleanOperator(); var precidence = (int)type / 100; var right = PrimaryBooleanExpression(); if (minPrecedence >= precidence) { right = BooleanExpression(right, precidence); } left = new BooleanBinaryExpression { Token = token, Left = left, Type = type, Right = right }; } return(left); }
public void Visit(BooleanBinaryExpression expression) { string op; switch (expression.Type) { case BooleanOperatorType.And: op = "AND "; break; case BooleanOperatorType.Or: op = "OR "; break; default: throw new NotSupportedException(); } Write(expression.Left); WriteLine(); Write(op); Write(expression.Right); }
public void TestInvertedBooleanBinaryOr() { //Test DeMorgan law for negation var actual = QueryBuilder.BooleanExpression <TestClass>(x => !(x.Long == 0 || x.String == "test")); var expected = new BooleanBinaryExpression() { Left = new BooleanComparisonExpression() { Type = BooleanComparisonType.NotEqualTo, Left = new ColumnReference() { Identifiers = new List <string>() { "Long" }, }, Right = new IntegerLiteral() { Value = 0 } }, Right = new BooleanComparisonExpression() { Type = BooleanComparisonType.NotEqualTo, Left = new ColumnReference() { Identifiers = new List <string>() { "String" }, }, Right = new StringLiteral() { Value = "test" } }, Type = BooleanBinaryType.AND }; actual.Should().BeEquivalentTo(expected, x => x.RespectingRuntimeTypes()); }
public void TestBooleanBinaryAnd() { var actual = QueryBuilder.BooleanExpression <TestClass>(x => x.Long == 0 && x.String == "test"); var expected = new BooleanBinaryExpression() { Left = new BooleanComparisonExpression() { Type = BooleanComparisonType.Equals, Left = new ColumnReference() { Identifiers = new List <string>() { "Long" }, }, Right = new IntegerLiteral() { Value = 0 } }, Right = new BooleanComparisonExpression() { Type = BooleanComparisonType.Equals, Left = new ColumnReference() { Identifiers = new List <string>() { "String" }, }, Right = new StringLiteral() { Value = "test" } }, Type = BooleanBinaryType.AND }; actual.Should().BeEquivalentTo(expected, x => x.RespectingRuntimeTypes()); }
public void TestBooleanBinaryOr() { BooleanBinaryExpression booleanBinaryExpression = new BooleanBinaryExpression() { Left = new BooleanComparisonExpression() { Left = new ColumnReference() { Identifiers = new List <string>() { "c1" } }, Right = new StringLiteral() { Value = "a" } }, Right = new BooleanComparisonExpression() { Left = new ColumnReference() { Identifiers = new List <string>() { "c2" } }, Right = new StringLiteral() { Value = "b" } }, Type = BooleanBinaryType.OR }; var expected = "(c1 = 'a') OR (c2 = 'b')"; var actual = booleanBinaryExpression.Print(); actual.Should().Be(expected); }
protected override object InternalVisit(BooleanBinaryExpression node) { Func <bool, bool, bool> func = null; switch (node.BinaryExpressionType) { case BooleanBinaryExpressionType.And: func = (first, second) => first && second; break; case BooleanBinaryExpressionType.Or: func = (first, second) => first || second; break; } return(new Func <Environment, object>(env => { // INFO(Richo): We don't need to implement short-circuit because it's not a requirement for SQL bool first = EvaluateExpression <bool>(node.FirstExpression, env); bool second = EvaluateExpression <bool>(node.SecondExpression, env); return func(first, second); })); }
public void TestParseBooleanExpression() { var actual = Parser.ParseFilter("c1 = 'test' AND c2 > 10", out var errors); var expected = new BooleanBinaryExpression() { Left = new BooleanComparisonExpression() { Left = new ColumnReference() { Identifiers = new List <string>() { "c1" } }, Right = new StringLiteral() { Value = "test" }, Type = BooleanComparisonType.Equals }, Right = new BooleanComparisonExpression() { Left = new ColumnReference() { Identifiers = new List <string>() { "c2" } }, Right = new IntegerLiteral() { Value = 10 }, Type = BooleanComparisonType.GreaterThan } }; actual.Should().BeEquivalentTo(expected, x => x.RespectingRuntimeTypes()); }
public override void VisitBooleanBinaryExpression(BooleanBinaryExpression booleanBinaryExpression) { bool inOrSet = false; //Check if it is an OR operation and we are not already inside of one //This is used at this time only for checking if an index can be used or not if (booleanBinaryExpression.Type == BooleanBinaryType.OR && !InOr) { inOrSet = true; InOr = true; } booleanBinaryExpression.Left.Accept(this); booleanBinaryExpression.Right.Accept(this); //Reset the in OR flag if (inOrSet) { InOr = false; } var rightExpression = PopStack(); var leftExpression = PopStack(); Expression expression = null; switch (booleanBinaryExpression.Type) { case BooleanBinaryType.AND: expression = Expression.AndAlso(leftExpression, rightExpression); break; case BooleanBinaryType.OR: expression = Expression.OrElse(leftExpression, rightExpression); break; } AddExpressionToStack(expression); }
private void VisitBooleanBinaryExpression(BooleanBinaryExpression expression, TSqlFragment parent, string sourceProperty) { //if (property.Fields.Count == 1) return; //if(expression.FirstExpression is BooleanComparisonExpression) //ColumnReferenceExpression operand; //if (sourceProperty == "FirstExpression") //{ // operand = parent.SecondExpression as ColumnReferenceExpression; //} //else if (sourceProperty == "SecondExpression") //{ // operand = parent.FirstExpression as ColumnReferenceExpression; //} //else { return; } //if (operand == null) //{ // return; //} }
private static BooleanExpression Binary_Internal(IEnumerable <BooleanExpression> expressions, BooleanBinaryType booleanBinaryType) { if (!(expressions is IReadOnlyList <BooleanExpression> list)) { list = expressions.ToList(); } if (list.Count == 0) { return(null); } var first = list.First(); if (list.Count == 1) { return(first); } var second = list[1]; var binaryExpression = new BooleanBinaryExpression() { Left = first, Right = second, Type = booleanBinaryType }; for (int i = 2; i < list.Count; i++) { binaryExpression = new BooleanBinaryExpression() { Left = binaryExpression, Right = list[i], Type = booleanBinaryType }; } return(binaryExpression); }
public override void VisitBetweenExpression(BetweenExpression betweenExpression) { //Convert the between expression into a boolean binary expression var convertedExpression = new BooleanBinaryExpression() { Left = new BooleanComparisonExpression() { Left = betweenExpression.Expression, Right = betweenExpression.From, Type = BooleanComparisonType.GreaterThanOrEqualTo }, Right = new BooleanComparisonExpression() { Left = betweenExpression.Expression, Right = betweenExpression.To, Type = BooleanComparisonType.LessThanOrEqualTo }, Type = BooleanBinaryType.AND }; //Visit the newly constructed boolean binary expression instead convertedExpression.Accept(this); }
public ISyntaxNode Visit(TSqlFragment node, TSqlFragment parent, string sourceProperty, ISyntaxNode result) { BooleanBinaryExpression expression = node as BooleanBinaryExpression; if (expression == null) { return(result); } StatementNode statement = result as StatementNode; if (statement == null) { return(result); } if (statement.VisitContext is WhereClause || // WHERE statement.VisitContext is QualifiedJoin) // ON { VisitBooleanBinaryExpression(expression, parent, sourceProperty); } return(result); }
public override void Visit(BooleanBinaryExpression node) { PredicatesFound = true; }
private static List<BooleanBinaryExpression> CreateExpressionTreeForUpdateSearch(List<BooleanIsNullExpression> isNulls) { var expressions = new List<BooleanBinaryExpression>(); BooleanBinaryExpression last = null; var counter = 0; foreach (var isNull in isNulls) { var boolExpression = new BooleanBinaryExpression { SecondExpression = isNull, BinaryExpressionType = BooleanBinaryExpressionType.Or }; if (last != null) { if (isNulls.Count - 1 == ++counter) { last.FirstExpression = isNulls.Last(); } else { last.FirstExpression = boolExpression; } } last = boolExpression; expressions.Add(last); } return expressions; }
public override void Visit(BooleanBinaryExpression node) { this.action(node); }
public override void ExplicitVisit(BooleanBinaryExpression fragment) { _fragments.Add(fragment); }
public override void ExplicitVisit(BooleanBinaryExpression node) { base.ExplicitVisit(node); ReplaceExpression(node, n => n.FirstExpression); ReplaceExpression(node, n => n.SecondExpression); }