public override void Visit(BooleanComparisonExpression expression)
{
if (expression.IsEqualityComparison())
{
Comparisons.Add(expression);
}
}
public override void VisitBooleanComparisonExpression(BooleanComparisonExpression booleanComparisonExpression)
{
var(fieldName, value) = CheckComparisonArguments(booleanComparisonExpression.Left, booleanComparisonExpression.Right);
switch (booleanComparisonExpression.Type)
{
case BooleanComparisonType.Equals:
Push(new Term()
{
FieldName = fieldName,
Value = GetTerm(value)
});
break;
case BooleanComparisonType.GreaterThan:
Push(new Range()
{
FieldName = fieldName,
GreaterThan = GetTerm(value)
});
break;
case BooleanComparisonType.GreaterThanOrEqualTo:
Push(new Range()
{
FieldName = fieldName,
GreaterThanEqual = GetTerm(value)
});
break;
case BooleanComparisonType.LessThan:
Push(new Range()
{
FieldName = fieldName,
LessThan = GetTerm(value)
});
break;
case BooleanComparisonType.LessThanOrEqualTo:
Push(new Range()
{
FieldName = fieldName,
LessThanEqual = GetTerm(value)
});
break;
case BooleanComparisonType.NotEqualTo:
Push(new Bool()
{
MustNot = new List <BoolOperation>()
{
new Term()
{
FieldName = fieldName,
Value = GetTerm(value),
}
}
});
break;
}
}
public void TestCloneBooleanComparisonExpression()
{
BooleanComparisonExpression booleanComparisonExpression = new BooleanComparisonExpression()
{
Type = BooleanComparisonType.Equals,
Left = new ColumnReference()
{
Identifiers = new List <string>()
{
"c1"
}
},
Right = new IntegerLiteral()
{
Value = 3
}
};
var clone = booleanComparisonExpression.Clone() as BooleanComparisonExpression;
Assert.AreEqual(booleanComparisonExpression, clone);
Assert.IsFalse(ReferenceEquals(booleanComparisonExpression, clone));
Assert.IsFalse(ReferenceEquals(booleanComparisonExpression.Left, clone.Left));
Assert.IsFalse(ReferenceEquals(booleanComparisonExpression.Right, clone.Right));
}
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(BooleanComparisonExpression expression)
{
if (expression.IsEqualityComparison())
{
Comparisons.Add(expression);
}
}
public void TestBinaryExpressionDivide()
{
var actual = QueryBuilder.BooleanExpression <TestClass>(x => (x.Long / 1) == 0);
var expected = new BooleanComparisonExpression()
{
Type = BooleanComparisonType.Equals,
Left = new Expressions.BinaryExpression()
{
Left = new ColumnReference()
{
Identifiers = new List <string>()
{
"Long"
},
},
Right = new IntegerLiteral()
{
Value = 1
},
Type = BinaryType.Divide
},
Right = new IntegerLiteral()
{
Value = 0
}
};
actual.Should().BeEquivalentTo(expected, x => x.RespectingRuntimeTypes());
}
public void TestBooleanComparisonExpressionAccept()
{
Mock <KoraliumSqlVisitor> mock = new Mock <KoraliumSqlVisitor>();
BooleanComparisonExpression booleanComparisonExpression = new BooleanComparisonExpression();
booleanComparisonExpression.Accept(mock.Object);
mock.Verify(x => x.VisitBooleanComparisonExpression(booleanComparisonExpression));
}
public override void ExplicitVisit(BooleanComparisonExpression node)
{
var secondExpression = node.SecondExpression.FirstNoneParenthesisExpression();
var firstExpression = node.FirstExpression.FirstNoneParenthesisExpression();
checkHasUnparametrizedWhereClauses(secondExpression, firstExpression);
base.ExplicitVisit(node);
}
public void Visit(BooleanComparisonExpression booleanComparisonExpression)
{
if (_innerVisitor != null)
{
booleanComparisonExpression.Accept(_innerVisitor);
}
booleanComparisonExpression.Left.Accept(this);
booleanComparisonExpression.Right.Accept(this);
}
public override void ExplicitVisit(BooleanComparisonExpression node)
{
var secondExpression = node.SecondExpression.FirstNoneParenthesisExpression();
var firstExpression = node.FirstExpression.FirstNoneParenthesisExpression();
checkHasUnparametrizedWhereClauses(secondExpression, firstExpression);
base.ExplicitVisit(node);
}
private void checkForNullLiterals(BooleanComparisonExpression comparisonExpression)
{
if (comparisonExpression == null) return;
var firstExpression = comparisonExpression.FirstExpression.FirstNoneParenthesisExpression();
var secondExpression = comparisonExpression.SecondExpression.FirstNoneParenthesisExpression();
checkHasNullLiteral(firstExpression, secondExpression, comparisonExpression.ComparisonType);
checkHasNullVariableReference(firstExpression, secondExpression, comparisonExpression.ComparisonType);
}
public override void Visit(BooleanComparisonExpression node)
{
var visitor = new ChildFunctionCallVisitor();
node.Accept(visitor);
if (visitor.UpperLowerFound)
{
UpperLowerFunctionCallInComparison = true;
}
}
internal gsWhereTermBase GetWhereTerm(BooleanComparisonExpression booleanComparisonExpression)
{
gsWhereTermCompare whereTerm = new gsWhereTermCompare();
whereTerm.Operator = booleanComparisonExpression.ComparisonType.ToCompareOperator();
whereTerm.FirstExpression = gsScalarExpressionParserFactory.CreateParser(booleanComparisonExpression.FirstExpression, null).Parse();
whereTerm.SecondExpression = gsScalarExpressionParserFactory.CreateParser(booleanComparisonExpression.SecondExpression, null).Parse();
return(whereTerm);
}
public override void ExplicitVisit(BooleanComparisonExpression node)
{
if (node.SecondExpression.FirstNoneParenthesisExpression() is Literal ||
node.FirstExpression.FirstNoneParenthesisExpression() is Literal)
{
IsSuspected = true;
}
base.ExplicitVisit(node);
}
public QsiBinaryExpressionNode VisitBooleanComparisonExpression(BooleanComparisonExpression booleanComparisonExpression)
{
return(TreeHelper.Create <QsiBinaryExpressionNode>(n =>
{
n.Left.SetValue(VisitScalarExpression(booleanComparisonExpression.FirstExpression));
n.Right.SetValue(VisitScalarExpression(booleanComparisonExpression.SecondExpression));
n.Operator = ConvertBooleanComparisonType(booleanComparisonExpression.ComparisonType);
}));
}
public override void ExplicitVisit(BooleanComparisonExpression node)
{
var secondFunction = node.SecondExpression as FunctionCall;
checkIsSuspected(secondFunction);
var firstFunction = node.FirstExpression as FunctionCall;
checkIsSuspected(firstFunction);
base.ExplicitVisit(node);
}
private BooleanComparisonExpression CreateSearchCondition(string keyColumn, BooleanComparisonExpression condition)
{
condition.ComparisonType = BooleanComparisonType.Equals;
condition.FirstExpression = new ScalarExpressionSnippet {
Script = string.Format("{0}.[{1}]", MergeIdentifierStrings.SourceName, keyColumn)
};
condition.SecondExpression = new ScalarExpressionSnippet {
Script = string.Format("{0}.[{1}]", MergeIdentifierStrings.TargetName, keyColumn)
};
return(condition);
}
private BooleanComparisonExpression CreateSearchConditionForTableWithNoKeys(BooleanComparisonExpression condition)
{
condition.ComparisonType = BooleanComparisonType.Equals;
condition.FirstExpression = new ScalarExpressionSnippet {
Script = string.Format("{0}.{1}", MergeIdentifierStrings.SourceName, "[???]")
};
condition.SecondExpression = new ScalarExpressionSnippet {
Script = string.Format("{0}.{1}", MergeIdentifierStrings.TargetName, "[???]")
};
return(condition);
}
public override void ExplicitVisit(BooleanComparisonExpression node)
{
var secondFunction = node.SecondExpression as FunctionCall;
checkIsSuspected(secondFunction);
var firstFunction = node.FirstExpression as FunctionCall;
checkIsSuspected(firstFunction);
base.ExplicitVisit(node);
}
private void BuildMultiKeySearchCondition(MergeSpecification specification)
{
var comparisons = new List <BooleanComparisonExpression>();
foreach (var column in _merge.Table.Columns.Where(p => p.IsKey))
{
var condition = new BooleanComparisonExpression();
comparisons.Add(CreateSearchCondition(column.Name.GetName(), condition));
}
specification.SearchCondition = CreateExpressionTreeForMultiKeySearchConditon(comparisons).First();
}
private void BuildMultiKeySearchCondition(MergeSpecification specification)
{
var comparisons = new List <BooleanComparisonExpression>();
foreach (var column in _keyColumns)
{
var condition = new BooleanComparisonExpression();
comparisons.Add(CreateSearchCondition(column, condition));
}
specification.SearchCondition = CreateExpressionTreeForMultiKeySearchConditon(comparisons).First();
}
public override void Visit(BooleanComparisonExpression exp)
{
if (exp.FirstExpression is ColumnReferenceExpression)
{
RbacWhereClause aWhereClause = new RbacWhereClause();
aWhereClause.Literal = RbacWhereClauseLiterals.BooleanExpression;
aWhereClause.OnTableAlias = ((ColumnReferenceExpression)exp.FirstExpression).MultiPartIdentifier.Identifiers.First().Value;
aWhereClause.OnColumn = ((ColumnReferenceExpression)exp.FirstExpression).MultiPartIdentifier.Identifiers.Last().Value;
aWhereClause.ConditionValues.Add(((Literal)exp.SecondExpression).Value);
aWhereClause.WhereClauseString = Query.Substring(exp.StartOffset, exp.FragmentLength);
WhereClauses.Add(aWhereClause);
}
}
private void checkForNullLiterals(BooleanComparisonExpression comparisonExpression)
{
if (comparisonExpression == null)
{
return;
}
var firstExpression = comparisonExpression.FirstExpression.FirstNoneParenthesisExpression();
var secondExpression = comparisonExpression.SecondExpression.FirstNoneParenthesisExpression();
checkHasNullLiteral(firstExpression, secondExpression, comparisonExpression.ComparisonType);
checkHasNullVariableReference(firstExpression, secondExpression, comparisonExpression.ComparisonType);
}
private bool TestCompare(BooleanComparisonExpression compare)
{
var expr1 = compare.FirstExpression;
var expr2 = compare.SecondExpression;
var type1 = expr1.GetType();
var type2 = expr2.GetType();
return(
(
(type1 == typeof(IntegerLiteral) || type1 == typeof(StringLiteral)) &&
(type2 == typeof(IntegerLiteral) || type2 == typeof(StringLiteral))
) &&
_comparer.Equals((expr1 as Literal)?.Value, (expr2 as Literal)?.Value));
}
private BooleanComparisonExpression BuildWhilePredicate(QuerySpecification subQuery)
{
var query = new BooleanComparisonExpression();
query.ComparisonType = BooleanComparisonType.GreaterThan;
var scalarQuery = (query.FirstExpression = new ScalarSubquery()) as ScalarSubquery;
scalarQuery.QueryExpression = subQuery;
query.SecondExpression = new IntegerLiteral
{
Value = "0"
};
return(query);
}
public override void VisitBooleanComparisonExpression(BooleanComparisonExpression booleanComparisonExpression)
{
booleanComparisonExpression.Left.Accept(this);
booleanComparisonExpression.Right.Accept(this);
var rightExpression = PopStack();
var leftExpression = PopStack();
var expression = PredicateUtils.CreateComparisonExpression(
leftExpression,
rightExpression,
booleanComparisonExpression.Type,
_visitorMetadata.OperationsProvider);
AddExpressionToStack(expression);
}
protected override object InternalVisit(BooleanComparisonExpression node)
{
var comparer = SQLComparer.Default;
Func <object, object, bool> func;
switch (node.ComparisonType)
{
case BooleanComparisonType.Equals:
func = (first, second) => 0 == comparer.Compare(first, second);
break;
case BooleanComparisonType.GreaterThan:
func = (first, second) => 1 == comparer.Compare(first, second);
break;
case BooleanComparisonType.LessThan:
func = (first, second) => - 1 == comparer.Compare(first, second);
break;
case BooleanComparisonType.NotLessThan:
case BooleanComparisonType.GreaterThanOrEqualTo:
func = (first, second) => - 1 < comparer.Compare(first, second);
break;
case BooleanComparisonType.NotGreaterThan:
case BooleanComparisonType.LessThanOrEqualTo:
func = (first, second) => 1 > comparer.Compare(first, second);
break;
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
func = (first, second) => 0 != comparer.Compare(first, second);
break;
case BooleanComparisonType.LeftOuterJoin:
case BooleanComparisonType.RightOuterJoin:
default:
throw new NotImplementedException();
}
return(new Func <Environment, object>((env) =>
{
var first = EvaluateExpression <object>(node.FirstExpression, env);
var second = EvaluateExpression <object>(node.SecondExpression, env);
return func(first, second);
}));
}
public override void ExplicitVisit(BooleanComparisonExpression node)
{
node.FirstExpression.Accept(this);
switch (node.ComparisonType)
{
case BooleanComparisonType.Equals:
_buffer.Append(" = ");
break;
case BooleanComparisonType.GreaterThan:
_buffer.Append(" > ");
break;
case BooleanComparisonType.GreaterThanOrEqualTo:
_buffer.Append(" >= ");
break;
case BooleanComparisonType.LessThan:
_buffer.Append(" < ");
break;
case BooleanComparisonType.LessThanOrEqualTo:
_buffer.Append(" < ");
break;
case BooleanComparisonType.NotEqualToBrackets:
_buffer.Append(" <> ");
break;
case BooleanComparisonType.NotEqualToExclamation:
_buffer.Append(" != ");
break;
case BooleanComparisonType.NotGreaterThan:
_buffer.Append(" !> ");
break;
case BooleanComparisonType.NotLessThan:
_buffer.Append(" !< ");
break;
default:
throw new InvalidOperationException();
}
node.SecondExpression.Accept(this);
}
public void TestStringEqualsNull()
{
var actual = QueryBuilder.BooleanExpression <TestClass>(x => x.String == null);
var expected = new BooleanComparisonExpression()
{
Type = BooleanComparisonType.Equals,
Left = new ColumnReference()
{
Identifiers = new List <string>()
{
"String"
},
},
Right = new NullLiteral()
};
actual.Should().BeEquivalentTo(expected, x => x.RespectingRuntimeTypes());
}
public void TestVisitBooleanComparisonExpression()
{
Mock <ScalarExpression> left = new Mock <ScalarExpression>();
Mock <ScalarExpression> right = new Mock <ScalarExpression>();
BooleanComparisonExpression booleanComparisonExpression = new BooleanComparisonExpression()
{
Left = left.Object,
Right = right.Object
};
KoraliumSqlVisitor koraliumSqlVisitor = new KoraliumSqlVisitor();
koraliumSqlVisitor.Visit(booleanComparisonExpression);
left.Verify(x => x.Accept(koraliumSqlVisitor));
right.Verify(x => x.Accept(koraliumSqlVisitor));
}
public override void ExplicitVisit(BooleanComparisonExpression node)
{
// ComparisonType + First + Second
cs.CodeBinaryOperatorExpression binary = new cs.CodeBinaryOperatorExpression();
binary.Operator = ConvertToBinaryOperatorType(node.ComparisonType);
binary.Left = TryBuildFromNode(node.FirstExpression, ref lastHasError, ref lastError);
binary.Right = TryBuildFromNode(node.SecondExpression, ref lastHasError, ref lastError);
if (lastHasError)
{
return;
}
// adjust left or right : boolean column - compare to int : true==1
// try get left type
// try get right type
this.lastExpression = binary;
}
public IEnumerable <IColumnRelationship> ParseBooleanComparisonExpression(BooleanComparisonExpression booleanComparisonExpression, IDictionary <string, ITable> tableByAliasIdentifier, IList <int> booleanComparisonExpressionIdentifiers, RelationshipOrigin relationshipOrigin)
{
if (booleanComparisonExpression.ComparisonType == BooleanComparisonType.NotEqualToBrackets || booleanComparisonExpression.ComparisonType == BooleanComparisonType.NotEqualToExclamation)
{
yield break;
}
var columnReferenceExpressions = _visitorProvider.GetColumnReferenceExpressions(booleanComparisonExpression).AsList();
if (columnReferenceExpressions.Count != 2)
{
yield break;
}
var fromColumnReferenceExpression = columnReferenceExpressions[0];
if (!TryParseColumn(fromColumnReferenceExpression, tableByAliasIdentifier, out IColumn fromColumn))
{
yield break;
}
var toColumnReferenceExpression = columnReferenceExpressions[1];
if (!TryParseColumn(toColumnReferenceExpression, tableByAliasIdentifier, out IColumn toColumn))
{
yield break;
}
var booleanComparisonExpressionIdentifier = booleanComparisonExpression.FirstTokenIndex + booleanComparisonExpression.LastTokenIndex;
if (booleanComparisonExpressionIdentifiers.Contains(booleanComparisonExpressionIdentifier))
{
yield break;
}
booleanComparisonExpressionIdentifiers.Add(booleanComparisonExpressionIdentifier);
var columnRelationship = new ColumnRelationship(fromColumn, toColumn, relationshipOrigin);
yield return(columnRelationship);
}
public void TestBooleanComparisionInvertedEquals()
{
var actual = QueryBuilder.BooleanExpression <TestClass>(x => !(x.String == "test"));
var expected = new BooleanComparisonExpression()
{
Type = BooleanComparisonType.NotEqualTo,
Left = new ColumnReference()
{
Identifiers = new List <string>()
{
"String"
},
},
Right = new StringLiteral()
{
Value = "test"
}
};
actual.Should().BeEquivalentTo(expected, x => x.RespectingRuntimeTypes());
}
public void TestBooleanComparisionLessThan()
{
var actual = QueryBuilder.BooleanExpression <TestClass>(x => x.Long < 3);
var expected = new BooleanComparisonExpression()
{
Type = BooleanComparisonType.LessThan,
Left = new ColumnReference()
{
Identifiers = new List <string>()
{
"Long"
},
},
Right = new IntegerLiteral()
{
Value = 3
}
};
actual.Should().BeEquivalentTo(expected, x => x.RespectingRuntimeTypes());
}
private string buildChunkedDelete(DeleteSpecification delete)
{
var counter = new DeclareVariableStatement();
var counterVariable = new DeclareVariableElement();
counterVariable.DataType = new SqlDataTypeReference() {SqlDataTypeOption = SqlDataTypeOption.Int};
counterVariable.VariableName = new Identifier() {Value = "@rowcount"};
counterVariable.Value = new IntegerLiteral() {Value = "10000"};
counter.Declarations.Add(counterVariable);
delete.TopRowFilter = new TopRowFilter();
delete.TopRowFilter.Expression = new ParenthesisExpression() {Expression = new IntegerLiteral() {Value = "10000"} };
var setCounter = new SetVariableStatement();
setCounter.Variable = new VariableReference() {Name = "@rowcount"};
setCounter.Expression = new GlobalVariableExpression() {Name = "@@rowcount"};
setCounter.AssignmentKind = AssignmentKind.Equals;
var deleteStatement = new DeleteStatement();
deleteStatement.DeleteSpecification = delete;
var beginEnd = new BeginEndBlockStatement();
beginEnd.StatementList = new StatementList();
beginEnd.StatementList.Statements.Add(deleteStatement);
beginEnd.StatementList.Statements.Add(setCounter);
var whilePredicate = new BooleanComparisonExpression();
whilePredicate.ComparisonType = BooleanComparisonType.GreaterThan;
whilePredicate.FirstExpression = new VariableReference() {Name = "@rowcount"};
whilePredicate.SecondExpression = new IntegerLiteral() {Value = "0"};
var whileStatement = new WhileStatement();
whileStatement.Predicate = whilePredicate;
whileStatement.Statement = beginEnd;
var text = ScriptDom.GenerateTSql(counter) + "\r\n" + ScriptDom.GenerateTSql(whileStatement);
return text;
}
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 ExplicitVisit(BooleanComparisonExpression node)
{
checkForNullLiterals(node);
base.ExplicitVisit(node);
}
private void BuildMultiKeySearchCondition(MergeSpecification specification)
{
var comparisons = new List<BooleanComparisonExpression>();
foreach (var column in _keyColumns)
{
var condition = new BooleanComparisonExpression();
comparisons.Add(CreateSearchCondition(column, condition));
}
specification.SearchCondition = CreateExpressionTreeForMultiKeySearchConditon(comparisons).First();
}
public override void ExplicitVisit(BooleanComparisonExpression fragment)
{
_fragments.Add(fragment);
}
private BooleanComparisonExpression CreateSearchCondition(string keyColumn, BooleanComparisonExpression condition)
{
condition.ComparisonType = BooleanComparisonType.Equals;
condition.FirstExpression = new ScalarExpressionSnippet { Script = string.Format("[{0}].[{1}]", MergeIdentifierStrings.SourceName, keyColumn) };
condition.SecondExpression = new ScalarExpressionSnippet { Script = string.Format("[{0}].[{1}]", MergeIdentifierStrings.TargetName, keyColumn) };
return condition;
}
private void BuildMultiKeySearchCondition(MergeSpecification specification)
{
var comparisons = new List<BooleanComparisonExpression>();
foreach (var column in _merge.Table.Columns.Where(p => p.IsKey))
{
var condition = new BooleanComparisonExpression();
comparisons.Add(CreateSearchCondition(column.Name.GetName(), condition));
}
specification.SearchCondition = CreateExpressionTreeForMultiKeySearchConditon(comparisons).First();
}
private BooleanComparisonExpression CreateSearchConditionForTableWithNoKeys(BooleanComparisonExpression condition)
{
condition.ComparisonType = BooleanComparisonType.Equals;
condition.FirstExpression = new ScalarExpressionSnippet { Script = string.Format("{0}.{1}", MergeIdentifierStrings.SourceName, "[???]") };
condition.SecondExpression = new ScalarExpressionSnippet { Script = string.Format("{0}.{1}", MergeIdentifierStrings.TargetName, "[???]") };
return condition;
}
private BooleanComparisonExpression BuildWhilePredicate(QuerySpecification subQuery)
{
var query = new BooleanComparisonExpression();
query.ComparisonType = BooleanComparisonType.GreaterThan;
var scalarQuery = (query.FirstExpression = new ScalarSubquery()) as ScalarSubquery;
scalarQuery.QueryExpression = subQuery;
query.SecondExpression = new IntegerLiteral
{
Value = "0"
};
return query;
}
public override void Visit(BooleanComparisonExpression node) { this.action(node); }