bool HasDependencyWithParent(SqlJoinedTable parent,
SqlJoinedTable child)
{
var sources = new HashSet <int>(child.Table.GetTables().Select(t => t.SourceID));
var dependent = false;
// check that parent has dependency on child
new QueryVisitor().VisitParentFirst(parent, e =>
{
if (dependent)
{
return(false);
}
if (e == child)
{
return(false);
}
var expression = e as ISqlExpression;
if (expression != null)
{
var field = GetUnderlayingField(expression);
if (field != null)
{
dependent = sources.Contains(field.SourceID);
}
}
return(!dependent);
});
return(dependent);
}
bool IsDependedOnJoin(SqlTableSource table, SqlJoinedTable testedJoin, HashSet <int> testedSources)
{
var dependent = false;
var currentSourceId = testedJoin.Table.SourceID;
// check everything that can be dependent on specific table
new QueryVisitor().VisitParentFirst(testedJoin, e =>
{
if (dependent)
{
return(false);
}
if (e is ISqlExpression expression)
{
var field = GetUnderlayingField(expression);
if (field != null)
{
var newField = GetNewField(field);
var local = testedSources.Contains(newField.SourceID);
if (local)
{
dependent = !CanWeReplaceField(table, newField, testedSources, currentSourceId);
}
}
}
return(!dependent);
});
return(dependent);
}
public JoinConditionExpression(SqlJoinedTable joinedTable)
: base(typeof(bool))
{
ArgumentUtility.CheckNotNull("joinedTable", joinedTable);
_joinedTable = joinedTable;
}
public void VisitJoinConditionExpression()
{
var resolvedTableInfo = new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c");
var leftKey = new SqlColumnDefinitionExpression(typeof(Cook), "c", "ID", false);
var rightKey = new SqlColumnDefinitionExpression(typeof(Cook), "a", "FK", false);
var joinInfo = new ResolvedJoinInfo(resolvedTableInfo, Expression.Equal(leftKey, rightKey));
var sqlTable = new SqlJoinedTable(joinInfo, JoinSemantics.Left);
var joinConditionExpression = new JoinConditionExpression(sqlTable);
_entityIdentityResolverMock
.Expect(
mock => mock.ResolvePotentialEntityComparison(
Arg <BinaryExpression> .Matches(b => b.Left == leftKey && b.Right == rightKey)))
.Return(null)
.WhenCalled(mi => mi.ReturnValue = mi.Arguments[0]);
_compoundComparisonSplitterMock
.Expect(
mock => mock.SplitPotentialCompoundComparison(
Arg <BinaryExpression> .Matches(b => b.Left == leftKey && b.Right == rightKey)))
.Return(null)
.WhenCalled(mi => mi.ReturnValue = mi.Arguments[0]);
var result = _visitor.Visit(joinConditionExpression);
_entityIdentityResolverMock.VerifyAllExpectations();
_compoundComparisonSplitterMock.VerifyAllExpectations();
var expectedExpression = Expression.Equal(leftKey, rightKey);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
void RemoveSource(SqlTableSource fromTable, SqlJoinedTable join)
{
if (_removedSources == null)
{
_removedSources = new HashSet <int>();
}
_removedSources.Add(join.Table.SourceID);
if (_equalityMap != null)
{
var keys = _equalityMap.Keys.Where(k => k.SourceID == join.Table.SourceID).ToArray();
foreach (var key in keys)
{
var newField = MapToSource(fromTable, key, fromTable.SourceID);
if (newField != null)
{
ReplaceField(key, newField);
}
_equalityMap.Remove(key);
}
}
ResetFieldSearchCache(join.Table);
}
public static JoinSequence Build(SqlJoinedTable root)
{
var joins = new List <SqlJoinExpression>();
Traverse(root, joins);
var result = new JoinSequence();
foreach (var item in joins)
{
if (!(item.Left is SqlJoinedTable))
{
result.Tables.Add(item.Left);
}
if (!(item.Right is SqlJoinedTable))
{
result.Tables.Add(item.Right);
}
result.JoinTypes.Add(item.JoinType);
result.Conditions.Add(item.Expression);
}
var pivot = result.Tables[0];
result.Pivot = pivot;
result.Tables.RemoveAt(0);
result.Tables = new ReadOnlyCollection <SqlTable>(result.Tables);
result.JoinTypes = new ReadOnlyCollection <SqlJoinType>(result.JoinTypes);
result.Conditions = new ReadOnlyCollection <SqlExpression>(result.Conditions);
return(result);
}
public JoinConditionExpression (SqlJoinedTable joinedTable)
: base (typeof (bool))
{
ArgumentUtility.CheckNotNull ("joinedTable", joinedTable);
_joinedTable = joinedTable;
}
public new void ToString()
{
var joinedTable = new SqlJoinedTable(SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(), JoinSemantics.Left);
var result = joinedTable.ToString();
Assert.That(result, Is.EqualTo("LEFT JOIN Kitchen.Cook"));
}
public void DifferentType()
{
var oldJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
var sqlJoinedTable = new SqlJoinedTable(oldJoinInfo, JoinSemantics.Left);
var newJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenRestaurant();
sqlJoinedTable.JoinInfo = newJoinInfo;
}
List <FoundEquality> SearchForFields(SqlTableSource manySource, SqlJoinedTable join)
{
var key = Tuple.Create(manySource, join.Table);
List <FoundEquality> found = null;
if (_fieldPairCache != null && _fieldPairCache.TryGetValue(key, out found))
{
return(found);
}
for (var i1 = 0; i1 < join.Condition.Conditions.Count; i1++)
{
var c = join.Condition.Conditions[i1];
if (c.IsOr)
{
found = null;
break;
}
if (c.ElementType != QueryElementType.Condition ||
c.Predicate.ElementType != QueryElementType.ExprExprPredicate ||
((SqlPredicate.ExprExpr)c.Predicate).Operator != SqlPredicate.Operator.Equal)
{
continue;
}
var predicate = (SqlPredicate.ExprExpr)c.Predicate;
var equality = new FoundEquality();
if (!MatchFields(manySource, join.Table,
GetUnderlayingField(predicate.Expr1),
GetUnderlayingField(predicate.Expr2),
equality))
{
continue;
}
equality.OneCondition = c;
if (found == null)
{
found = new List <FoundEquality>();
}
found.Add(equality);
}
if (_fieldPairCache == null)
{
_fieldPairCache = new Dictionary <Tuple <SqlTableSource, SqlTableSource>, List <FoundEquality> >();
}
_fieldPairCache.Add(key, found);
return(found);
}
public ITableInfo VisitSqlJoinedTable(SqlJoinedTable joinedTable)
{
ArgumentUtility.CheckNotNull("joinedTable", joinedTable);
var newJoinInfo = _stage.ApplyContext(joinedTable.JoinInfo, _expressionContext, _mappingResolutionContext);
joinedTable.JoinInfo = newJoinInfo;
return(joinedTable);
}
public ITableInfo VisitSqlJoinedTable(SqlJoinedTable joinedTable)
{
ArgumentUtility.CheckNotNull("joinedTable", joinedTable);
var resolvedJoinInfo = _stage.ResolveJoinInfo(joinedTable.JoinInfo, _context);
joinedTable.JoinInfo = resolvedJoinInfo;
return(joinedTable.GetResolvedTableInfo());
}
public void ToString_WithJoins()
{
var joinedTable = new SqlJoinedTable(SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(), JoinSemantics.Left);
var joinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
var memberInfo = typeof(Kitchen).GetProperty("Cook");
joinedTable.GetOrAddLeftJoin(joinInfo, memberInfo);
var result = joinedTable.ToString();
Assert.That(result, Is.EqualTo("LEFT JOIN Kitchen.Cook LEFT JOIN Kitchen.Cook"));
}
public void SameType()
{
var oldJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
var sqlJoinedTable = new SqlJoinedTable(oldJoinInfo, JoinSemantics.Left);
var newJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_CookSubstitution();
sqlJoinedTable.JoinInfo = newJoinInfo;
Assert.That(sqlJoinedTable.JoinInfo.ItemType, Is.EqualTo(newJoinInfo.ItemType));
Assert.That(sqlJoinedTable.JoinSemantics, Is.EqualTo(JoinSemantics.Left));
}
void ReplaceSource(SqlTableSource fromTable, SqlJoinedTable oldSource, SqlTableSource newSource)
{
var oldFields = GetFields(oldSource.Table.Source);
var newFields = GetFields(newSource.Source);
foreach (var old in oldFields)
{
var newField = newFields[old.Key];
ReplaceField(old.Value, newField);
}
RemoveSource(fromTable, oldSource);
}
private static void GenerateTextForSqlJoinedTable(IJoinInfoVisitor visitor, SqlJoinedTable joinedTable, ISqlCommandBuilder commandBuilder)
{
ArgumentUtility.CheckNotNull("joinedTable", joinedTable);
// TODO RMLNQSQL-4: This check can be removed.
if (joinedTable.JoinSemantics == JoinSemantics.Inner)
{
throw new NotSupportedException("SqlJoinedTables with INNER JoinSemantics are currently not supported. (RMLNQSQL-4)");
}
commandBuilder.Append(" LEFT OUTER JOIN ");
joinedTable.JoinInfo.Accept(visitor);
}
public void ApplyContext_SqlJoinedTable_SameJoinInfo()
{
var joinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
var sqlJoinedTable = new SqlJoinedTable(joinInfo, JoinSemantics.Left);
_stageMock
.Expect(mock => mock.ApplyContext(joinInfo, SqlExpressionContext.ValueRequired, _mappingresolutionContext))
.Return(joinInfo);
_stageMock.Replay();
var result = SqlContextTableInfoVisitor.ApplyContext(sqlJoinedTable, SqlExpressionContext.ValueRequired, _stageMock, _mappingresolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(sqlJoinedTable));
}
public void Accept_VisitorSupportingExpressionType()
{
var oldJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
var sqlJoinedTable = new SqlJoinedTable(oldJoinInfo, JoinSemantics.Left);
var visitorMock = MockRepository.GenerateMock <ISqlTableBaseVisitor> ();
visitorMock.Expect(mock => mock.VisitSqlJoinedTable(sqlJoinedTable));
visitorMock.Replay();
sqlJoinedTable.Accept(visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(sqlJoinedTable.JoinSemantics, Is.EqualTo(JoinSemantics.Left));
}
void CollectEqualFields(SqlJoinedTable join)
{
if (join.JoinType != JoinType.Inner)
{
return;
}
if (join.Condition.Conditions.Any(c => c.IsOr))
{
return;
}
for (var i1 = 0; i1 < join.Condition.Conditions.Count; i1++)
{
var c = join.Condition.Conditions[i1];
if (c.ElementType != QueryElementType.Condition ||
c.Predicate.ElementType != QueryElementType.ExprExprPredicate ||
((SqlPredicate.ExprExpr)c.Predicate).Operator != SqlPredicate.Operator.Equal)
{
continue;
}
var predicate = (SqlPredicate.ExprExpr)c.Predicate;
var field1 = GetUnderlayingField(predicate.Expr1);
if (field1 == null)
{
continue;
}
var field2 = GetUnderlayingField(predicate.Expr2);
if (field2 == null)
{
continue;
}
if (field1.Equals(field2))
{
continue;
}
AddEqualFields(field1, field2, join.Table.SourceID);
AddEqualFields(field2, field1, join.Table.SourceID);
}
}
protected override Expression VisitMemberExpression(MemberExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
var preparedMemberExpression = (MemberExpression)TranslateExpression(expression, Context, Stage, MethodCallTransformerProvider);
var joinInfo = new UnresolvedCollectionJoinInfo(preparedMemberExpression.Expression, preparedMemberExpression.Member);
var joinedTable = new SqlJoinedTable(joinInfo, JoinSemantics.Inner);
var oldStyleJoinedTable = _tableGenerator(joinedTable);
var sqlTableReferenceExpression = new SqlTableReferenceExpression(oldStyleJoinedTable);
FromExpressionInfo = new FromExpressionInfo(
oldStyleJoinedTable, new Ordering[0], sqlTableReferenceExpression, new JoinConditionExpression(joinedTable));
return(sqlTableReferenceExpression);
}
public void ResolveJoinedTable()
{
var joinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
var joinedTable = new SqlJoinedTable(joinInfo, JoinSemantics.Left);
var fakeJoinInfo = SqlStatementModelObjectMother.CreateResolvedJoinInfo();
_stageMock
.Expect(mock => mock.ResolveJoinInfo(joinInfo, _mappingResolutionContext))
.Return(fakeJoinInfo);
_stageMock.Replay();
_visitor.ResolveJoinedTable(joinedTable);
Assert.That(joinedTable.JoinInfo, Is.SameAs(fakeJoinInfo));
}
public void Accept_ITableInfoVisitor()
{
var oldJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
var sqlJoinedTable = new SqlJoinedTable(oldJoinInfo, JoinSemantics.Left);
var fakeResult = new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c");
var visitorMock = MockRepository.GenerateMock <ITableInfoVisitor>();
visitorMock
.Expect(mock => mock.VisitSqlJoinedTable(sqlJoinedTable))
.Return(fakeResult);
var result = ((ITableInfo)sqlJoinedTable).Accept(visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
bool IsDependedBetweenJoins(SqlTableSource table, SqlJoinedTable testedJoin)
{
var testedSources = new HashSet <int>(testedJoin.Table.GetTables().Select(t => t.SourceID));
foreach (var tableJoin in table.Joins)
{
if (testedSources.Contains(tableJoin.Table.SourceID))
{
continue;
}
if (IsDependedOnJoin(table, tableJoin, testedSources))
{
return(true);
}
}
return(IsDependedExcludeJoins(testedSources));
}
private static void Traverse(SqlJoinedTable root, ICollection <SqlJoinExpression> output)
{
var left = root.JoinExpression.Left;
var joinedLeft = left as SqlJoinedTable;
if (joinedLeft != null)
{
Traverse(joinedLeft, output);
}
output.Add(root.JoinExpression);
var right = root.JoinExpression.Right;
var joinedRight = right as SqlJoinedTable;
if (joinedRight != null)
{
Traverse(joinedRight, output);
}
}
