Allow override of cardinality on With clauses

ThatRendle · ThatRendle · commit 69caf3a5a5b2 · 2012-02-22T10:51:05.000Z
diff --git a/Simple.Data.Ado/QueryBuilder.cs b/Simple.Data.Ado/QueryBuilder.cs
@@ -110,28 +110,11 @@ private void HandleWithClauses()
                 {
                     if (withClause.ObjectReference.GetOwner().IsNull())
                     {
-                        var joinClause =
-                            _query.Clauses.OfType<JoinClause>().FirstOrDefault(j => j.Table.GetAliasOrName() == withClause.ObjectReference.GetAliasOrName());
-                        if (joinClause != null)
-                        {
-                            _columns =
-                                _columns.Concat(
-                                    _schema.FindTable(joinClause.Table.GetName()).Columns.Select(
-                                        c => new ObjectReference(c.ActualName, joinClause.Table)))
-                                    .ToArray();
-                            relationTypeDict[joinClause.Table] = withClause.Type == WithType.One
-                                                                     ? RelationType.ManyToOne
-                                                                     : RelationType.OneToMany;
-                        }
+                        HandleWithClauseUsingAssociatedJoinClause(relationTypeDict, withClause);
                     }
                     else
                     {
-                        relationTypeDict[withClause.ObjectReference] = RelationType.None;
-                        _columns =
-                            _columns.Concat(
-                                _schema.FindTable(withClause.ObjectReference.GetName()).Columns.Select(
-                                    c => new ObjectReference(c.ActualName, withClause.ObjectReference)))
-                                .ToArray();
+                        HandleWithClauseUsingNaturalJoin(withClause, relationTypeDict);
                     }
                 }
                 _columns =
@@ -141,6 +124,45 @@ private void HandleWithClauses()
             }
         }
 
+        private void HandleWithClauseUsingAssociatedJoinClause(Dictionary<ObjectReference, RelationType> relationTypeDict, WithClause withClause)
+        {
+            var joinClause =
+                _query.Clauses.OfType<JoinClause>().FirstOrDefault(
+                    j => j.Table.GetAliasOrName() == withClause.ObjectReference.GetAliasOrName());
+            if (joinClause != null)
+            {
+                _columns =
+                    _columns.Concat(
+                        _schema.FindTable(joinClause.Table.GetName()).Columns.Select(
+                            c => new ObjectReference(c.ActualName, joinClause.Table)))
+                        .ToArray();
+                relationTypeDict[joinClause.Table] = WithTypeToRelationType(withClause.Type, RelationType.OneToMany);
+            }
+        }
+
+        private void HandleWithClauseUsingNaturalJoin(WithClause withClause, Dictionary<ObjectReference, RelationType> relationTypeDict)
+        {
+            relationTypeDict[withClause.ObjectReference] = WithTypeToRelationType(withClause.Type, RelationType.None);
+            _columns =
+                _columns.Concat(
+                    _schema.FindTable(withClause.ObjectReference.GetName()).Columns.Select(
+                        c => new ObjectReference(c.ActualName, withClause.ObjectReference)))
+                    .ToArray();
+        }
+
+        private static RelationType WithTypeToRelationType(WithType withType, RelationType defaultRelationType)
+        {
+            switch (withType)
+            {
+                case WithType.One:
+                    return RelationType.ManyToOne;
+                case WithType.Many:
+                    return RelationType.OneToMany;
+                default:
+                    return defaultRelationType;
+            }
+        }
+
         private bool IsCoreTable(ObjectReference tableReference)
         {
             if (ReferenceEquals(tableReference, null)) throw new ArgumentNullException("tableReference");
diff --git a/Simple.Data.BehaviourTest/Query/WithTest.cs b/Simple.Data.BehaviourTest/Query/WithTest.cs
@@ -82,6 +82,22 @@ public void SingleWithClauseUsingReferenceShouldUseJoin()
             GeneratedSqlIs(expectedSql);
         }
 
+        [Test]
+        public void SingleWithOneClauseUsingReferenceShouldUseJoinAndForceOne()
+        {
+            const string expectedSql = "select " +
+                "[dbo].[department].[id],[dbo].[department].[name]," +
+                "[dbo].[employee].[id] as [__with1__employee__id],[dbo].[employee].[name] as [__with1__employee__name]," +
+                "[dbo].[employee].[managerid] as [__with1__employee__managerid],[dbo].[employee].[departmentid] as [__with1__employee__departmentid]" +
+                " from [dbo].[department] left join [dbo].[employee] on ([dbo].[department].[id] = [dbo].[employee].[departmentid])";
+
+            var q = _db.Departments.All().WithOne(_db.Departments.Employee);
+
+            EatException(() => q.ToList());
+
+            GeneratedSqlIs(expectedSql);
+        }
+
         [Test]
         public void SingleWithClauseUsingReferenceWithAliasShouldApplyAliasToSql()
         {
