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